// DO NOT EDIT. Generated by tensorflow-op-codegen/src/main.rs.
#![allow(
    non_snake_case,
    trivial_casts,
    unused_parens,
    unused_qualifications,
    unused_variables
)]

/// Builder for the `Abort` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Abort {
    error_msg: ::std::option::Option<::std::string::String>,
    exit_without_error: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Abort' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct AbortInst {
    /// An instance of a fully built Abort Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Abort {
    /// Creates a new `Abort`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `error_msg` attribute.
    pub fn error_msg<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.error_msg = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `exit_without_error` attribute.
    pub fn exit_without_error<ArgType: ::std::convert::Into<bool>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.exit_without_error = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Abort` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("Abort", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.error_msg {
                nd.set_attr_string("error_msg", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.exit_without_error {
                nd.set_attr_bool("exit_without_error", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Abort' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(&self, scope: &mut crate::Scope) -> crate::Result<AbortInst> {
        let op = scope.new_operation("Abort", |builder| {
            if let ::std::option::Option::Some(value) = &self.error_msg {
                builder.set_attr_string("error_msg", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.exit_without_error {
                builder.set_attr_bool("exit_without_error", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(AbortInst { op })
    }
}
impl AbortInst {}
impl From<AbortInst> for crate::Operation {
    fn from(inst: AbortInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Abort::new().build(scope)`.
pub fn abort(scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
    Abort::new().build(scope)
}

/// Builder for the `Abs` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Abs {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Abs' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct AbsInst {
    /// An instance of a fully built Abs Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Abs {
    /// Creates a new `Abs`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Abs` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        x: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Abs", |nd| {
            nd.add_input(x);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Abs' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<AbsInst> {
        let op = scope.new_operation("Abs", |builder| {
            builder.add_input(x);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(AbsInst { op })
    }
}
impl AbsInst {
    /// Returns the 'y' Output of this 'Abs' operation.
    pub fn y(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'Abs' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<AbsInst> for crate::Operation {
    fn from(inst: AbsInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Abs::new().build(x, scope)`.
pub fn abs<O0: ::std::convert::Into<crate::Output>>(
    x: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Abs::new().build(x, scope)
}

/// Builder for the `AccumulateNV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct AccumulateNV2 {
    N: ::std::option::Option<i64>,
    T: ::std::option::Option<crate::DataType>,
    shape: ::std::option::Option<crate::Shape>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'AccumulateNV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct AccumulateNV2Inst {
    /// An instance of a fully built AccumulateNV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl AccumulateNV2 {
    /// Creates a new `AccumulateNV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `N` attribute.
    pub fn N<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.N = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shape` attribute.
    pub fn shape<ArgType: ::std::convert::Into<crate::Shape>>(mut self, value: ArgType) -> Self {
        self.shape = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `AccumulateNV2` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        inputs: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(inputs.into(), scope)
    }
    fn build_impl(
        &self,
        inputs: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("AccumulateNV2", |nd| {
            nd.add_input(inputs);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.N {
                nd.set_attr_int("N", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shape {
                nd.set_attr_shape("shape", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'AccumulateNV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        inputs: Vec<crate::Output>,
        scope: &mut crate::Scope,
    ) -> crate::Result<AccumulateNV2Inst> {
        let op = scope.new_operation("AccumulateNV2", |builder| {
            builder.add_input_list(&inputs);
            builder.set_attr_int("N", inputs.clone().len() as i64)?;
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shape {
                builder.set_attr_shape("shape", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(AccumulateNV2Inst { op })
    }
}
impl AccumulateNV2Inst {
    /// Returns the 'sum' Output of this 'AccumulateNV2' operation.
    pub fn sum(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns a Vector of inputs for 'inputs' Input of this AccumulateNV2 operation.
    pub fn inputs(&self) -> crate::Result<Vec<crate::Input>> {
        let mut Inputs = vec![];
        for i in 0..self.op.get_attr_int("N")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
}
impl From<AccumulateNV2Inst> for crate::Operation {
    fn from(inst: AccumulateNV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `AccumulateNV2::new().build(inputs, scope)`.
pub fn accumulate_nv2<O0: ::std::convert::Into<crate::Output>>(
    inputs: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    AccumulateNV2::new().build(inputs, scope)
}

/// Builder for the `AccumulatorApplyGradient` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct AccumulatorApplyGradient {
    dtype: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'AccumulatorApplyGradient' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct AccumulatorApplyGradientInst {
    /// An instance of a fully built AccumulatorApplyGradient Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl AccumulatorApplyGradient {
    /// Creates a new `AccumulatorApplyGradient`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `dtype` attribute.
    pub fn dtype<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `AccumulatorApplyGradient` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        handle: O0,
        local_step: O1,
        gradient: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(handle.into(), local_step.into(), gradient.into(), scope)
    }
    fn build_impl(
        &self,
        handle: crate::Output,
        local_step: crate::Output,
        gradient: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("AccumulatorApplyGradient", |nd| {
            nd.add_input(handle);
            nd.add_input(local_step);
            nd.add_input(gradient);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                nd.set_attr_type("dtype", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'AccumulatorApplyGradient' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        handle: crate::Output,
        local_step: crate::Output,
        gradient: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<AccumulatorApplyGradientInst> {
        let op = scope.new_operation("AccumulatorApplyGradient", |builder| {
            builder.add_input(handle);
            builder.add_input(local_step);
            builder.add_input(gradient);
            if let ::std::option::Option::Some(value) = &self.dtype {
                builder.set_attr_type("dtype", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(AccumulatorApplyGradientInst { op })
    }
}
impl AccumulatorApplyGradientInst {
    /// Returns the 'handle' Input of this 'AccumulatorApplyGradient' operation.
    pub fn handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'local_step' Input of this 'AccumulatorApplyGradient' operation.
    pub fn local_step(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'gradient' Input of this 'AccumulatorApplyGradient' operation.
    pub fn gradient(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<AccumulatorApplyGradientInst> for crate::Operation {
    fn from(inst: AccumulatorApplyGradientInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `AccumulatorApplyGradient::new().build(handle, local_step, gradient, scope)`.
pub fn accumulator_apply_gradient<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    handle: O0,
    local_step: O1,
    gradient: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    AccumulatorApplyGradient::new().build(handle, local_step, gradient, scope)
}

/// Builder for the `AccumulatorNumAccumulated` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct AccumulatorNumAccumulated {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'AccumulatorNumAccumulated' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct AccumulatorNumAccumulatedInst {
    /// An instance of a fully built AccumulatorNumAccumulated Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl AccumulatorNumAccumulated {
    /// Creates a new `AccumulatorNumAccumulated`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `AccumulatorNumAccumulated` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        handle: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(handle.into(), scope)
    }
    fn build_impl(
        &self,
        handle: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("AccumulatorNumAccumulated", |nd| {
            nd.add_input(handle);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'AccumulatorNumAccumulated' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        handle: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<AccumulatorNumAccumulatedInst> {
        let op = scope.new_operation("AccumulatorNumAccumulated", |builder| {
            builder.add_input(handle);
            ::std::result::Result::Ok(())
        })?;
        Ok(AccumulatorNumAccumulatedInst { op })
    }
}
impl AccumulatorNumAccumulatedInst {
    /// Returns the 'num_accumulated' Output of this 'AccumulatorNumAccumulated' operation.
    pub fn num_accumulated(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'handle' Input of this 'AccumulatorNumAccumulated' operation.
    pub fn handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<AccumulatorNumAccumulatedInst> for crate::Operation {
    fn from(inst: AccumulatorNumAccumulatedInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `AccumulatorNumAccumulated::new().build(handle, scope)`.
pub fn accumulator_num_accumulated<O0: ::std::convert::Into<crate::Output>>(
    handle: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    AccumulatorNumAccumulated::new().build(handle, scope)
}

/// Builder for the `AccumulatorSetGlobalStep` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct AccumulatorSetGlobalStep {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'AccumulatorSetGlobalStep' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct AccumulatorSetGlobalStepInst {
    /// An instance of a fully built AccumulatorSetGlobalStep Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl AccumulatorSetGlobalStep {
    /// Creates a new `AccumulatorSetGlobalStep`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `AccumulatorSetGlobalStep` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        handle: O0,
        new_global_step: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(handle.into(), new_global_step.into(), scope)
    }
    fn build_impl(
        &self,
        handle: crate::Output,
        new_global_step: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("AccumulatorSetGlobalStep", |nd| {
            nd.add_input(handle);
            nd.add_input(new_global_step);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'AccumulatorSetGlobalStep' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        handle: crate::Output,
        new_global_step: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<AccumulatorSetGlobalStepInst> {
        let op = scope.new_operation("AccumulatorSetGlobalStep", |builder| {
            builder.add_input(handle);
            builder.add_input(new_global_step);
            ::std::result::Result::Ok(())
        })?;
        Ok(AccumulatorSetGlobalStepInst { op })
    }
}
impl AccumulatorSetGlobalStepInst {
    /// Returns the 'handle' Input of this 'AccumulatorSetGlobalStep' operation.
    pub fn handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'new_global_step' Input of this 'AccumulatorSetGlobalStep' operation.
    pub fn new_global_step(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<AccumulatorSetGlobalStepInst> for crate::Operation {
    fn from(inst: AccumulatorSetGlobalStepInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `AccumulatorSetGlobalStep::new().build(handle, new_global_step, scope)`.
pub fn accumulator_set_global_step<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    handle: O0,
    new_global_step: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    AccumulatorSetGlobalStep::new().build(handle, new_global_step, scope)
}

/// Builder for the `AccumulatorTakeGradient` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct AccumulatorTakeGradient {
    dtype: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'AccumulatorTakeGradient' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct AccumulatorTakeGradientInst {
    /// An instance of a fully built AccumulatorTakeGradient Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl AccumulatorTakeGradient {
    /// Creates a new `AccumulatorTakeGradient`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `dtype` attribute.
    pub fn dtype<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `AccumulatorTakeGradient` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        handle: O0,
        num_required: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(handle.into(), num_required.into(), scope)
    }
    fn build_impl(
        &self,
        handle: crate::Output,
        num_required: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("AccumulatorTakeGradient", |nd| {
            nd.add_input(handle);
            nd.add_input(num_required);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                nd.set_attr_type("dtype", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'AccumulatorTakeGradient' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        handle: crate::Output,
        num_required: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<AccumulatorTakeGradientInst> {
        let op = scope.new_operation("AccumulatorTakeGradient", |builder| {
            builder.add_input(handle);
            builder.add_input(num_required);
            if let ::std::option::Option::Some(value) = &self.dtype {
                builder.set_attr_type("dtype", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(AccumulatorTakeGradientInst { op })
    }
}
impl AccumulatorTakeGradientInst {
    /// Returns the 'average' Output of this 'AccumulatorTakeGradient' operation.
    pub fn average(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'handle' Input of this 'AccumulatorTakeGradient' operation.
    pub fn handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'num_required' Input of this 'AccumulatorTakeGradient' operation.
    pub fn num_required(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<AccumulatorTakeGradientInst> for crate::Operation {
    fn from(inst: AccumulatorTakeGradientInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `AccumulatorTakeGradient::new().build(handle, num_required, scope)`.
pub fn accumulator_take_gradient<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    handle: O0,
    num_required: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    AccumulatorTakeGradient::new().build(handle, num_required, scope)
}

/// Builder for the `Acos` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Acos {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Acos' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct AcosInst {
    /// An instance of a fully built Acos Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Acos {
    /// Creates a new `Acos`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Acos` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        x: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Acos", |nd| {
            nd.add_input(x);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Acos' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<AcosInst> {
        let op = scope.new_operation("Acos", |builder| {
            builder.add_input(x);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(AcosInst { op })
    }
}
impl AcosInst {
    /// Returns the 'y' Output of this 'Acos' operation.
    pub fn y(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'Acos' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<AcosInst> for crate::Operation {
    fn from(inst: AcosInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Acos::new().build(x, scope)`.
pub fn acos<O0: ::std::convert::Into<crate::Output>>(
    x: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Acos::new().build(x, scope)
}

/// Builder for the `Acosh` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Acosh {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Acosh' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct AcoshInst {
    /// An instance of a fully built Acosh Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Acosh {
    /// Creates a new `Acosh`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Acosh` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        x: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Acosh", |nd| {
            nd.add_input(x);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Acosh' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<AcoshInst> {
        let op = scope.new_operation("Acosh", |builder| {
            builder.add_input(x);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(AcoshInst { op })
    }
}
impl AcoshInst {
    /// Returns the 'y' Output of this 'Acosh' operation.
    pub fn y(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'Acosh' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<AcoshInst> for crate::Operation {
    fn from(inst: AcoshInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Acosh::new().build(x, scope)`.
pub fn acosh<O0: ::std::convert::Into<crate::Output>>(
    x: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Acosh::new().build(x, scope)
}

/// Builder for the `Add` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Add {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Add' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct AddInst {
    /// An instance of a fully built Add Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Add {
    /// Creates a new `Add`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Add` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        x: O0,
        y: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), y.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        y: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Add", |nd| {
            nd.add_input(x);
            nd.add_input(y);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Add' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        y: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<AddInst> {
        let op = scope.new_operation("Add", |builder| {
            builder.add_input(x);
            builder.add_input(y);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(AddInst { op })
    }
}
impl AddInst {
    /// Returns the 'z' Output of this 'Add' operation.
    pub fn z(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'Add' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'y' Input of this 'Add' operation.
    pub fn y(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<AddInst> for crate::Operation {
    fn from(inst: AddInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Add::new().build(x, y, scope)`.
pub fn add<O0: ::std::convert::Into<crate::Output>, O1: ::std::convert::Into<crate::Output>>(
    x: O0,
    y: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Add::new().build(x, y, scope)
}

/// Builder for the `AddManySparseToTensorsMap` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct AddManySparseToTensorsMap {
    T: ::std::option::Option<crate::DataType>,
    container: ::std::option::Option<::std::string::String>,
    shared_name: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'AddManySparseToTensorsMap' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct AddManySparseToTensorsMapInst {
    /// An instance of a fully built AddManySparseToTensorsMap Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl AddManySparseToTensorsMap {
    /// Creates a new `AddManySparseToTensorsMap`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `container` attribute.
    pub fn container<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.container = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shared_name` attribute.
    pub fn shared_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.shared_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `AddManySparseToTensorsMap` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        sparse_indices: O0,
        sparse_values: O1,
        sparse_shape: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            sparse_indices.into(),
            sparse_values.into(),
            sparse_shape.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        sparse_indices: crate::Output,
        sparse_values: crate::Output,
        sparse_shape: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("AddManySparseToTensorsMap", |nd| {
            nd.add_input(sparse_indices);
            nd.add_input(sparse_values);
            nd.add_input(sparse_shape);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.container {
                nd.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                nd.set_attr_string("shared_name", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'AddManySparseToTensorsMap' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        sparse_indices: crate::Output,
        sparse_values: crate::Output,
        sparse_shape: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<AddManySparseToTensorsMapInst> {
        let op = scope.new_operation("AddManySparseToTensorsMap", |builder| {
            builder.add_input(sparse_indices);
            builder.add_input(sparse_values);
            builder.add_input(sparse_shape);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.container {
                builder.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                builder.set_attr_string("shared_name", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(AddManySparseToTensorsMapInst { op })
    }
}
impl AddManySparseToTensorsMapInst {
    /// Returns the 'sparse_handles' Output of this 'AddManySparseToTensorsMap' operation.
    pub fn sparse_handles(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'sparse_indices' Input of this 'AddManySparseToTensorsMap' operation.
    pub fn sparse_indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'sparse_values' Input of this 'AddManySparseToTensorsMap' operation.
    pub fn sparse_values(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'sparse_shape' Input of this 'AddManySparseToTensorsMap' operation.
    pub fn sparse_shape(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<AddManySparseToTensorsMapInst> for crate::Operation {
    fn from(inst: AddManySparseToTensorsMapInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `AddManySparseToTensorsMap::new().build(sparse_indices, sparse_values, sparse_shape, scope)`.
pub fn add_many_sparse_to_tensors_map<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    sparse_indices: O0,
    sparse_values: O1,
    sparse_shape: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    AddManySparseToTensorsMap::new().build(sparse_indices, sparse_values, sparse_shape, scope)
}

/// Builder for the `AddN` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct AddN {
    N: ::std::option::Option<i64>,
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'AddN' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct AddNInst {
    /// An instance of a fully built AddN Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl AddN {
    /// Creates a new `AddN`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `N` attribute.
    pub fn N<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.N = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `AddN` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        inputs: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(inputs.into(), scope)
    }
    fn build_impl(
        &self,
        inputs: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("AddN", |nd| {
            nd.add_input(inputs);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.N {
                nd.set_attr_int("N", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'AddN' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        inputs: Vec<crate::Output>,
        scope: &mut crate::Scope,
    ) -> crate::Result<AddNInst> {
        let op = scope.new_operation("AddN", |builder| {
            builder.add_input_list(&inputs);
            builder.set_attr_int("N", inputs.clone().len() as i64)?;
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(AddNInst { op })
    }
}
impl AddNInst {
    /// Returns the 'sum' Output of this 'AddN' operation.
    pub fn sum(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns a Vector of inputs for 'inputs' Input of this AddN operation.
    pub fn inputs(&self) -> crate::Result<Vec<crate::Input>> {
        let mut Inputs = vec![];
        for i in 0..self.op.get_attr_int("N")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
}
impl From<AddNInst> for crate::Operation {
    fn from(inst: AddNInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `AddN::new().build(inputs, scope)`.
pub fn add_n<O0: ::std::convert::Into<crate::Output>>(
    inputs: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    AddN::new().build(inputs, scope)
}

/// Builder for the `AddSparseToTensorsMap` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct AddSparseToTensorsMap {
    T: ::std::option::Option<crate::DataType>,
    container: ::std::option::Option<::std::string::String>,
    shared_name: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'AddSparseToTensorsMap' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct AddSparseToTensorsMapInst {
    /// An instance of a fully built AddSparseToTensorsMap Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl AddSparseToTensorsMap {
    /// Creates a new `AddSparseToTensorsMap`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `container` attribute.
    pub fn container<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.container = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shared_name` attribute.
    pub fn shared_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.shared_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `AddSparseToTensorsMap` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        sparse_indices: O0,
        sparse_values: O1,
        sparse_shape: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            sparse_indices.into(),
            sparse_values.into(),
            sparse_shape.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        sparse_indices: crate::Output,
        sparse_values: crate::Output,
        sparse_shape: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("AddSparseToTensorsMap", |nd| {
            nd.add_input(sparse_indices);
            nd.add_input(sparse_values);
            nd.add_input(sparse_shape);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.container {
                nd.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                nd.set_attr_string("shared_name", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'AddSparseToTensorsMap' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        sparse_indices: crate::Output,
        sparse_values: crate::Output,
        sparse_shape: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<AddSparseToTensorsMapInst> {
        let op = scope.new_operation("AddSparseToTensorsMap", |builder| {
            builder.add_input(sparse_indices);
            builder.add_input(sparse_values);
            builder.add_input(sparse_shape);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.container {
                builder.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                builder.set_attr_string("shared_name", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(AddSparseToTensorsMapInst { op })
    }
}
impl AddSparseToTensorsMapInst {
    /// Returns the 'sparse_handle' Output of this 'AddSparseToTensorsMap' operation.
    pub fn sparse_handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'sparse_indices' Input of this 'AddSparseToTensorsMap' operation.
    pub fn sparse_indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'sparse_values' Input of this 'AddSparseToTensorsMap' operation.
    pub fn sparse_values(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'sparse_shape' Input of this 'AddSparseToTensorsMap' operation.
    pub fn sparse_shape(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<AddSparseToTensorsMapInst> for crate::Operation {
    fn from(inst: AddSparseToTensorsMapInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `AddSparseToTensorsMap::new().build(sparse_indices, sparse_values, sparse_shape, scope)`.
pub fn add_sparse_to_tensors_map<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    sparse_indices: O0,
    sparse_values: O1,
    sparse_shape: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    AddSparseToTensorsMap::new().build(sparse_indices, sparse_values, sparse_shape, scope)
}

/// Builder for the `AddV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct AddV2 {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'AddV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct AddV2Inst {
    /// An instance of a fully built AddV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl AddV2 {
    /// Creates a new `AddV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `AddV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        x: O0,
        y: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), y.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        y: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("AddV2", |nd| {
            nd.add_input(x);
            nd.add_input(y);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'AddV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        y: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<AddV2Inst> {
        let op = scope.new_operation("AddV2", |builder| {
            builder.add_input(x);
            builder.add_input(y);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(AddV2Inst { op })
    }
}
impl AddV2Inst {
    /// Returns the 'z' Output of this 'AddV2' operation.
    pub fn z(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'AddV2' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'y' Input of this 'AddV2' operation.
    pub fn y(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<AddV2Inst> for crate::Operation {
    fn from(inst: AddV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `AddV2::new().build(x, y, scope)`.
pub fn add_v2<O0: ::std::convert::Into<crate::Output>, O1: ::std::convert::Into<crate::Output>>(
    x: O0,
    y: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    AddV2::new().build(x, y, scope)
}

/// Builder for the `AdjustContrast` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct AdjustContrast {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'AdjustContrast' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct AdjustContrastInst {
    /// An instance of a fully built AdjustContrast Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl AdjustContrast {
    /// Creates a new `AdjustContrast`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `AdjustContrast` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
    >(
        &self,
        images: O0,
        contrast_factor: O1,
        min_value: O2,
        max_value: O3,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            images.into(),
            contrast_factor.into(),
            min_value.into(),
            max_value.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        images: crate::Output,
        contrast_factor: crate::Output,
        min_value: crate::Output,
        max_value: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("AdjustContrast", |nd| {
            nd.add_input(images);
            nd.add_input(contrast_factor);
            nd.add_input(min_value);
            nd.add_input(max_value);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'AdjustContrast' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        images: crate::Output,
        contrast_factor: crate::Output,
        min_value: crate::Output,
        max_value: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<AdjustContrastInst> {
        let op = scope.new_operation("AdjustContrast", |builder| {
            builder.add_input(images);
            builder.add_input(contrast_factor);
            builder.add_input(min_value);
            builder.add_input(max_value);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(AdjustContrastInst { op })
    }
}
impl AdjustContrastInst {
    /// Returns the 'output' Output of this 'AdjustContrast' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'images' Input of this 'AdjustContrast' operation.
    pub fn images(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'contrast_factor' Input of this 'AdjustContrast' operation.
    pub fn contrast_factor(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'min_value' Input of this 'AdjustContrast' operation.
    pub fn min_value(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'max_value' Input of this 'AdjustContrast' operation.
    pub fn max_value(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
}
impl From<AdjustContrastInst> for crate::Operation {
    fn from(inst: AdjustContrastInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `AdjustContrast::new().build(images, contrast_factor, min_value, max_value, scope)`.
pub fn adjust_contrast<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
>(
    images: O0,
    contrast_factor: O1,
    min_value: O2,
    max_value: O3,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    AdjustContrast::new().build(images, contrast_factor, min_value, max_value, scope)
}

/// Builder for the `AdjustContrastv2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct AdjustContrastv2 {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'AdjustContrastv2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct AdjustContrastv2Inst {
    /// An instance of a fully built AdjustContrastv2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl AdjustContrastv2 {
    /// Creates a new `AdjustContrastv2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `AdjustContrastv2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        images: O0,
        contrast_factor: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(images.into(), contrast_factor.into(), scope)
    }
    fn build_impl(
        &self,
        images: crate::Output,
        contrast_factor: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("AdjustContrastv2", |nd| {
            nd.add_input(images);
            nd.add_input(contrast_factor);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'AdjustContrastv2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        images: crate::Output,
        contrast_factor: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<AdjustContrastv2Inst> {
        let op = scope.new_operation("AdjustContrastv2", |builder| {
            builder.add_input(images);
            builder.add_input(contrast_factor);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(AdjustContrastv2Inst { op })
    }
}
impl AdjustContrastv2Inst {
    /// Returns the 'output' Output of this 'AdjustContrastv2' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'images' Input of this 'AdjustContrastv2' operation.
    pub fn images(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'contrast_factor' Input of this 'AdjustContrastv2' operation.
    pub fn contrast_factor(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<AdjustContrastv2Inst> for crate::Operation {
    fn from(inst: AdjustContrastv2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `AdjustContrastv2::new().build(images, contrast_factor, scope)`.
pub fn adjust_contrastv2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    images: O0,
    contrast_factor: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    AdjustContrastv2::new().build(images, contrast_factor, scope)
}

/// Builder for the `AdjustHue` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct AdjustHue {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'AdjustHue' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct AdjustHueInst {
    /// An instance of a fully built AdjustHue Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl AdjustHue {
    /// Creates a new `AdjustHue`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `AdjustHue` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        images: O0,
        delta: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(images.into(), delta.into(), scope)
    }
    fn build_impl(
        &self,
        images: crate::Output,
        delta: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("AdjustHue", |nd| {
            nd.add_input(images);
            nd.add_input(delta);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'AdjustHue' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        images: crate::Output,
        delta: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<AdjustHueInst> {
        let op = scope.new_operation("AdjustHue", |builder| {
            builder.add_input(images);
            builder.add_input(delta);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(AdjustHueInst { op })
    }
}
impl AdjustHueInst {
    /// Returns the 'output' Output of this 'AdjustHue' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'images' Input of this 'AdjustHue' operation.
    pub fn images(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'delta' Input of this 'AdjustHue' operation.
    pub fn delta(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<AdjustHueInst> for crate::Operation {
    fn from(inst: AdjustHueInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `AdjustHue::new().build(images, delta, scope)`.
pub fn adjust_hue<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    images: O0,
    delta: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    AdjustHue::new().build(images, delta, scope)
}

/// Builder for the `AdjustSaturation` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct AdjustSaturation {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'AdjustSaturation' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct AdjustSaturationInst {
    /// An instance of a fully built AdjustSaturation Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl AdjustSaturation {
    /// Creates a new `AdjustSaturation`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `AdjustSaturation` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        images: O0,
        scale: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(images.into(), scale.into(), scope)
    }
    fn build_impl(
        &self,
        images: crate::Output,
        scale: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("AdjustSaturation", |nd| {
            nd.add_input(images);
            nd.add_input(scale);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'AdjustSaturation' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        images: crate::Output,
        scale: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<AdjustSaturationInst> {
        let op = scope.new_operation("AdjustSaturation", |builder| {
            builder.add_input(images);
            builder.add_input(scale);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(AdjustSaturationInst { op })
    }
}
impl AdjustSaturationInst {
    /// Returns the 'output' Output of this 'AdjustSaturation' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'images' Input of this 'AdjustSaturation' operation.
    pub fn images(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'scale' Input of this 'AdjustSaturation' operation.
    pub fn scale(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<AdjustSaturationInst> for crate::Operation {
    fn from(inst: AdjustSaturationInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `AdjustSaturation::new().build(images, scale, scope)`.
pub fn adjust_saturation<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    images: O0,
    scale: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    AdjustSaturation::new().build(images, scale, scope)
}

/// Builder for the `All` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct All {
    keep_dims: ::std::option::Option<bool>,
    Tidx: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'All' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct AllInst {
    /// An instance of a fully built All Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl All {
    /// Creates a new `All`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `keep_dims` attribute.
    pub fn keep_dims<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.keep_dims = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tidx` attribute.
    pub fn Tidx<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Tidx = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `All` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        reduction_indices: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), reduction_indices.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        reduction_indices: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("All", |nd| {
            nd.add_input(input);
            nd.add_input(reduction_indices);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.keep_dims {
                nd.set_attr_bool("keep_dims", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tidx {
                nd.set_attr_type("Tidx", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'All' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        reduction_indices: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<AllInst> {
        let op = scope.new_operation("All", |builder| {
            builder.add_input(input);
            builder.add_input(reduction_indices);
            if let ::std::option::Option::Some(value) = &self.keep_dims {
                builder.set_attr_bool("keep_dims", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tidx {
                builder.set_attr_type("Tidx", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(AllInst { op })
    }
}
impl AllInst {
    /// Returns the 'output' Output of this 'All' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'All' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'reduction_indices' Input of this 'All' operation.
    pub fn reduction_indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<AllInst> for crate::Operation {
    fn from(inst: AllInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `All::new().build(input, reduction_indices, scope)`.
pub fn all<O0: ::std::convert::Into<crate::Output>, O1: ::std::convert::Into<crate::Output>>(
    input: O0,
    reduction_indices: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    All::new().build(input, reduction_indices, scope)
}

/// Builder for the `AllCandidateSampler` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct AllCandidateSampler {
    num_true: ::std::option::Option<i64>,
    num_sampled: ::std::option::Option<i64>,
    unique: ::std::option::Option<bool>,
    seed: ::std::option::Option<i64>,
    seed2: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'AllCandidateSampler' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct AllCandidateSamplerInst {
    /// An instance of a fully built AllCandidateSampler Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl AllCandidateSampler {
    /// Creates a new `AllCandidateSampler`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `num_true` attribute.
    pub fn num_true<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.num_true = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `num_sampled` attribute.
    pub fn num_sampled<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.num_sampled = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `unique` attribute.
    pub fn unique<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.unique = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `seed` attribute.
    pub fn seed<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.seed = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `seed2` attribute.
    pub fn seed2<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.seed2 = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `AllCandidateSampler` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        true_classes: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(true_classes.into(), scope)
    }
    fn build_impl(
        &self,
        true_classes: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("AllCandidateSampler", |nd| {
            nd.add_input(true_classes);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.num_true {
                nd.set_attr_int("num_true", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_sampled {
                nd.set_attr_int("num_sampled", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.unique {
                nd.set_attr_bool("unique", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed {
                nd.set_attr_int("seed", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed2 {
                nd.set_attr_int("seed2", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'AllCandidateSampler' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        true_classes: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<AllCandidateSamplerInst> {
        let op = scope.new_operation("AllCandidateSampler", |builder| {
            builder.add_input(true_classes);
            if let ::std::option::Option::Some(value) = &self.num_true {
                builder.set_attr_int("num_true", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_sampled {
                builder.set_attr_int("num_sampled", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.unique {
                builder.set_attr_bool("unique", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed {
                builder.set_attr_int("seed", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed2 {
                builder.set_attr_int("seed2", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(AllCandidateSamplerInst { op })
    }
}
impl AllCandidateSamplerInst {
    /// Returns the 'sampled_candidates' Output of this 'AllCandidateSampler' operation.
    pub fn sampled_candidates(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'true_expected_count' Output of this 'AllCandidateSampler' operation.
    pub fn true_expected_count(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'sampled_expected_count' Output of this 'AllCandidateSampler' operation.
    pub fn sampled_expected_count(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns the 'true_classes' Input of this 'AllCandidateSampler' operation.
    pub fn true_classes(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<AllCandidateSamplerInst> for crate::Operation {
    fn from(inst: AllCandidateSamplerInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `AllCandidateSampler::new().build(true_classes, scope)`.
pub fn all_candidate_sampler<O0: ::std::convert::Into<crate::Output>>(
    true_classes: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    AllCandidateSampler::new().build(true_classes, scope)
}

/// Builder for the `AllToAll` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct AllToAll {
    T: ::std::option::Option<crate::DataType>,
    concat_dimension: ::std::option::Option<i64>,
    split_dimension: ::std::option::Option<i64>,
    split_count: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'AllToAll' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct AllToAllInst {
    /// An instance of a fully built AllToAll Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl AllToAll {
    /// Creates a new `AllToAll`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `concat_dimension` attribute.
    pub fn concat_dimension<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.concat_dimension = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `split_dimension` attribute.
    pub fn split_dimension<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.split_dimension = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `split_count` attribute.
    pub fn split_count<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.split_count = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `AllToAll` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        group_assignment: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), group_assignment.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        group_assignment: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("AllToAll", |nd| {
            nd.add_input(input);
            nd.add_input(group_assignment);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.concat_dimension {
                nd.set_attr_int("concat_dimension", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.split_dimension {
                nd.set_attr_int("split_dimension", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.split_count {
                nd.set_attr_int("split_count", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'AllToAll' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        group_assignment: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<AllToAllInst> {
        let op = scope.new_operation("AllToAll", |builder| {
            builder.add_input(input);
            builder.add_input(group_assignment);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.concat_dimension {
                builder.set_attr_int("concat_dimension", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.split_dimension {
                builder.set_attr_int("split_dimension", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.split_count {
                builder.set_attr_int("split_count", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(AllToAllInst { op })
    }
}
impl AllToAllInst {
    /// Returns the 'output' Output of this 'AllToAll' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'AllToAll' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'group_assignment' Input of this 'AllToAll' operation.
    pub fn group_assignment(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<AllToAllInst> for crate::Operation {
    fn from(inst: AllToAllInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `AllToAll::new().build(input, group_assignment, scope)`.
pub fn all_to_all<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    input: O0,
    group_assignment: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    AllToAll::new().build(input, group_assignment, scope)
}

/// Builder for the `Angle` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Angle {
    T: ::std::option::Option<crate::DataType>,
    Tout: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Angle' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct AngleInst {
    /// An instance of a fully built Angle Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Angle {
    /// Creates a new `Angle`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tout` attribute.
    pub fn Tout<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Tout = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Angle` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Angle", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tout {
                nd.set_attr_type("Tout", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Angle' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<AngleInst> {
        let op = scope.new_operation("Angle", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tout {
                builder.set_attr_type("Tout", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(AngleInst { op })
    }
}
impl AngleInst {
    /// Returns the 'output' Output of this 'Angle' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'Angle' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<AngleInst> for crate::Operation {
    fn from(inst: AngleInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Angle::new().build(input, scope)`.
pub fn angle<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Angle::new().build(input, scope)
}

/// Builder for the `AnonymousHashTable` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct AnonymousHashTable {
    key_dtype: ::std::option::Option<crate::DataType>,
    value_dtype: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'AnonymousHashTable' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct AnonymousHashTableInst {
    /// An instance of a fully built AnonymousHashTable Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl AnonymousHashTable {
    /// Creates a new `AnonymousHashTable`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `key_dtype` attribute.
    pub fn key_dtype<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.key_dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `value_dtype` attribute.
    pub fn value_dtype<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.value_dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `AnonymousHashTable` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("AnonymousHashTable", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.key_dtype {
                nd.set_attr_type("key_dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.value_dtype {
                nd.set_attr_type("value_dtype", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'AnonymousHashTable' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        scope: &mut crate::Scope,
    ) -> crate::Result<AnonymousHashTableInst> {
        let op = scope.new_operation("AnonymousHashTable", |builder| {
            if let ::std::option::Option::Some(value) = &self.key_dtype {
                builder.set_attr_type("key_dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.value_dtype {
                builder.set_attr_type("value_dtype", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(AnonymousHashTableInst { op })
    }
}
impl AnonymousHashTableInst {
    /// Returns the 'table_handle' Output of this 'AnonymousHashTable' operation.
    pub fn table_handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
}
impl From<AnonymousHashTableInst> for crate::Operation {
    fn from(inst: AnonymousHashTableInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `AnonymousHashTable::new().build(scope)`.
pub fn anonymous_hash_table(scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
    AnonymousHashTable::new().build(scope)
}

/// Builder for the `AnonymousIterator` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct AnonymousIterator {
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'AnonymousIterator' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct AnonymousIteratorInst {
    /// An instance of a fully built AnonymousIterator Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl AnonymousIterator {
    /// Creates a new `AnonymousIterator`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `AnonymousIterator` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("AnonymousIterator", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'AnonymousIterator' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(&self, scope: &mut crate::Scope) -> crate::Result<AnonymousIteratorInst> {
        let op = scope.new_operation("AnonymousIterator", |builder| {
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(AnonymousIteratorInst { op })
    }
}
impl AnonymousIteratorInst {
    /// Returns the 'handle' Output of this 'AnonymousIterator' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
}
impl From<AnonymousIteratorInst> for crate::Operation {
    fn from(inst: AnonymousIteratorInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `AnonymousIterator::new().build(scope)`.
pub fn anonymous_iterator(scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
    AnonymousIterator::new().build(scope)
}

/// Builder for the `AnonymousIteratorV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct AnonymousIteratorV2 {
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'AnonymousIteratorV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct AnonymousIteratorV2Inst {
    /// An instance of a fully built AnonymousIteratorV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl AnonymousIteratorV2 {
    /// Creates a new `AnonymousIteratorV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `AnonymousIteratorV2` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("AnonymousIteratorV2", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'AnonymousIteratorV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        scope: &mut crate::Scope,
    ) -> crate::Result<AnonymousIteratorV2Inst> {
        let op = scope.new_operation("AnonymousIteratorV2", |builder| {
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(AnonymousIteratorV2Inst { op })
    }
}
impl AnonymousIteratorV2Inst {
    /// Returns the 'handle' Output of this 'AnonymousIteratorV2' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'deleter' Output of this 'AnonymousIteratorV2' operation.
    pub fn deleter(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
}
impl From<AnonymousIteratorV2Inst> for crate::Operation {
    fn from(inst: AnonymousIteratorV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `AnonymousIteratorV2::new().build(scope)`.
pub fn anonymous_iterator_v2(scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
    AnonymousIteratorV2::new().build(scope)
}

/// Builder for the `AnonymousIteratorV3` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct AnonymousIteratorV3 {
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'AnonymousIteratorV3' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct AnonymousIteratorV3Inst {
    /// An instance of a fully built AnonymousIteratorV3 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl AnonymousIteratorV3 {
    /// Creates a new `AnonymousIteratorV3`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `AnonymousIteratorV3` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("AnonymousIteratorV3", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'AnonymousIteratorV3' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        scope: &mut crate::Scope,
    ) -> crate::Result<AnonymousIteratorV3Inst> {
        let op = scope.new_operation("AnonymousIteratorV3", |builder| {
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(AnonymousIteratorV3Inst { op })
    }
}
impl AnonymousIteratorV3Inst {
    /// Returns the 'handle' Output of this 'AnonymousIteratorV3' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
}
impl From<AnonymousIteratorV3Inst> for crate::Operation {
    fn from(inst: AnonymousIteratorV3Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `AnonymousIteratorV3::new().build(scope)`.
pub fn anonymous_iterator_v3(scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
    AnonymousIteratorV3::new().build(scope)
}

/// Builder for the `AnonymousMemoryCache` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct AnonymousMemoryCache {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'AnonymousMemoryCache' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct AnonymousMemoryCacheInst {
    /// An instance of a fully built AnonymousMemoryCache Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl AnonymousMemoryCache {
    /// Creates a new `AnonymousMemoryCache`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `AnonymousMemoryCache` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("AnonymousMemoryCache", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'AnonymousMemoryCache' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        scope: &mut crate::Scope,
    ) -> crate::Result<AnonymousMemoryCacheInst> {
        let op = scope.new_operation("AnonymousMemoryCache", |builder| {
            ::std::result::Result::Ok(())
        })?;
        Ok(AnonymousMemoryCacheInst { op })
    }
}
impl AnonymousMemoryCacheInst {
    /// Returns the 'handle' Output of this 'AnonymousMemoryCache' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'deleter' Output of this 'AnonymousMemoryCache' operation.
    pub fn deleter(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
}
impl From<AnonymousMemoryCacheInst> for crate::Operation {
    fn from(inst: AnonymousMemoryCacheInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `AnonymousMemoryCache::new().build(scope)`.
pub fn anonymous_memory_cache(scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
    AnonymousMemoryCache::new().build(scope)
}

/// Builder for the `AnonymousMultiDeviceIterator` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct AnonymousMultiDeviceIterator {
    devices: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'AnonymousMultiDeviceIterator' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct AnonymousMultiDeviceIteratorInst {
    /// An instance of a fully built AnonymousMultiDeviceIterator Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl AnonymousMultiDeviceIterator {
    /// Creates a new `AnonymousMultiDeviceIterator`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `devices` attribute.
    pub fn devices<ArgType: ::std::convert::Into<::std::vec::Vec<::std::string::String>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.devices = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `AnonymousMultiDeviceIterator` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("AnonymousMultiDeviceIterator", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.devices {
                nd.set_attr_string_list("devices", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'AnonymousMultiDeviceIterator' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        scope: &mut crate::Scope,
    ) -> crate::Result<AnonymousMultiDeviceIteratorInst> {
        let op = scope.new_operation("AnonymousMultiDeviceIterator", |builder| {
            if let ::std::option::Option::Some(value) = &self.devices {
                builder.set_attr_string_list("devices", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(AnonymousMultiDeviceIteratorInst { op })
    }
}
impl AnonymousMultiDeviceIteratorInst {
    /// Returns the 'handle' Output of this 'AnonymousMultiDeviceIterator' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'deleter' Output of this 'AnonymousMultiDeviceIterator' operation.
    pub fn deleter(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
}
impl From<AnonymousMultiDeviceIteratorInst> for crate::Operation {
    fn from(inst: AnonymousMultiDeviceIteratorInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `AnonymousMultiDeviceIterator::new().build(scope)`.
pub fn anonymous_multi_device_iterator(
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    AnonymousMultiDeviceIterator::new().build(scope)
}

/// Builder for the `AnonymousMultiDeviceIteratorV3` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct AnonymousMultiDeviceIteratorV3 {
    devices: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'AnonymousMultiDeviceIteratorV3' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct AnonymousMultiDeviceIteratorV3Inst {
    /// An instance of a fully built AnonymousMultiDeviceIteratorV3 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl AnonymousMultiDeviceIteratorV3 {
    /// Creates a new `AnonymousMultiDeviceIteratorV3`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `devices` attribute.
    pub fn devices<ArgType: ::std::convert::Into<::std::vec::Vec<::std::string::String>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.devices = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `AnonymousMultiDeviceIteratorV3` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("AnonymousMultiDeviceIteratorV3", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.devices {
                nd.set_attr_string_list("devices", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'AnonymousMultiDeviceIteratorV3' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        scope: &mut crate::Scope,
    ) -> crate::Result<AnonymousMultiDeviceIteratorV3Inst> {
        let op = scope.new_operation("AnonymousMultiDeviceIteratorV3", |builder| {
            if let ::std::option::Option::Some(value) = &self.devices {
                builder.set_attr_string_list("devices", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(AnonymousMultiDeviceIteratorV3Inst { op })
    }
}
impl AnonymousMultiDeviceIteratorV3Inst {
    /// Returns the 'handle' Output of this 'AnonymousMultiDeviceIteratorV3' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
}
impl From<AnonymousMultiDeviceIteratorV3Inst> for crate::Operation {
    fn from(inst: AnonymousMultiDeviceIteratorV3Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `AnonymousMultiDeviceIteratorV3::new().build(scope)`.
pub fn anonymous_multi_device_iterator_v3(
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    AnonymousMultiDeviceIteratorV3::new().build(scope)
}

/// Builder for the `AnonymousMutableDenseHashTable` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct AnonymousMutableDenseHashTable {
    key_dtype: ::std::option::Option<crate::DataType>,
    value_dtype: ::std::option::Option<crate::DataType>,
    value_shape: ::std::option::Option<crate::Shape>,
    initial_num_buckets: ::std::option::Option<i64>,
    max_load_factor: ::std::option::Option<f32>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'AnonymousMutableDenseHashTable' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct AnonymousMutableDenseHashTableInst {
    /// An instance of a fully built AnonymousMutableDenseHashTable Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl AnonymousMutableDenseHashTable {
    /// Creates a new `AnonymousMutableDenseHashTable`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `key_dtype` attribute.
    pub fn key_dtype<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.key_dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `value_dtype` attribute.
    pub fn value_dtype<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.value_dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `value_shape` attribute.
    pub fn value_shape<ArgType: ::std::convert::Into<crate::Shape>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.value_shape = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `initial_num_buckets` attribute.
    pub fn initial_num_buckets<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.initial_num_buckets = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `max_load_factor` attribute.
    pub fn max_load_factor<ArgType: ::std::convert::Into<f32>>(mut self, value: ArgType) -> Self {
        self.max_load_factor = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `AnonymousMutableDenseHashTable` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        empty_key: O0,
        deleted_key: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(empty_key.into(), deleted_key.into(), scope)
    }
    fn build_impl(
        &self,
        empty_key: crate::Output,
        deleted_key: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("AnonymousMutableDenseHashTable", |nd| {
            nd.add_input(empty_key);
            nd.add_input(deleted_key);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.key_dtype {
                nd.set_attr_type("key_dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.value_dtype {
                nd.set_attr_type("value_dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.value_shape {
                nd.set_attr_shape("value_shape", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.initial_num_buckets {
                nd.set_attr_int("initial_num_buckets", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.max_load_factor {
                nd.set_attr_float("max_load_factor", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'AnonymousMutableDenseHashTable' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        empty_key: crate::Output,
        deleted_key: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<AnonymousMutableDenseHashTableInst> {
        let op = scope.new_operation("AnonymousMutableDenseHashTable", |builder| {
            builder.add_input(empty_key);
            builder.add_input(deleted_key);
            if let ::std::option::Option::Some(value) = &self.key_dtype {
                builder.set_attr_type("key_dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.value_dtype {
                builder.set_attr_type("value_dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.value_shape {
                builder.set_attr_shape("value_shape", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.initial_num_buckets {
                builder.set_attr_int("initial_num_buckets", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.max_load_factor {
                builder.set_attr_float("max_load_factor", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(AnonymousMutableDenseHashTableInst { op })
    }
}
impl AnonymousMutableDenseHashTableInst {
    /// Returns the 'table_handle' Output of this 'AnonymousMutableDenseHashTable' operation.
    pub fn table_handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'empty_key' Input of this 'AnonymousMutableDenseHashTable' operation.
    pub fn empty_key(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'deleted_key' Input of this 'AnonymousMutableDenseHashTable' operation.
    pub fn deleted_key(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<AnonymousMutableDenseHashTableInst> for crate::Operation {
    fn from(inst: AnonymousMutableDenseHashTableInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `AnonymousMutableDenseHashTable::new().build(empty_key, deleted_key, scope)`.
pub fn anonymous_mutable_dense_hash_table<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    empty_key: O0,
    deleted_key: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    AnonymousMutableDenseHashTable::new().build(empty_key, deleted_key, scope)
}

/// Builder for the `AnonymousMutableHashTable` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct AnonymousMutableHashTable {
    key_dtype: ::std::option::Option<crate::DataType>,
    value_dtype: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'AnonymousMutableHashTable' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct AnonymousMutableHashTableInst {
    /// An instance of a fully built AnonymousMutableHashTable Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl AnonymousMutableHashTable {
    /// Creates a new `AnonymousMutableHashTable`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `key_dtype` attribute.
    pub fn key_dtype<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.key_dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `value_dtype` attribute.
    pub fn value_dtype<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.value_dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `AnonymousMutableHashTable` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("AnonymousMutableHashTable", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.key_dtype {
                nd.set_attr_type("key_dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.value_dtype {
                nd.set_attr_type("value_dtype", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'AnonymousMutableHashTable' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        scope: &mut crate::Scope,
    ) -> crate::Result<AnonymousMutableHashTableInst> {
        let op = scope.new_operation("AnonymousMutableHashTable", |builder| {
            if let ::std::option::Option::Some(value) = &self.key_dtype {
                builder.set_attr_type("key_dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.value_dtype {
                builder.set_attr_type("value_dtype", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(AnonymousMutableHashTableInst { op })
    }
}
impl AnonymousMutableHashTableInst {
    /// Returns the 'table_handle' Output of this 'AnonymousMutableHashTable' operation.
    pub fn table_handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
}
impl From<AnonymousMutableHashTableInst> for crate::Operation {
    fn from(inst: AnonymousMutableHashTableInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `AnonymousMutableHashTable::new().build(scope)`.
pub fn anonymous_mutable_hash_table(scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
    AnonymousMutableHashTable::new().build(scope)
}

/// Builder for the `AnonymousMutableHashTableOfTensors` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct AnonymousMutableHashTableOfTensors {
    key_dtype: ::std::option::Option<crate::DataType>,
    value_dtype: ::std::option::Option<crate::DataType>,
    value_shape: ::std::option::Option<crate::Shape>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'AnonymousMutableHashTableOfTensors' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct AnonymousMutableHashTableOfTensorsInst {
    /// An instance of a fully built AnonymousMutableHashTableOfTensors Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl AnonymousMutableHashTableOfTensors {
    /// Creates a new `AnonymousMutableHashTableOfTensors`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `key_dtype` attribute.
    pub fn key_dtype<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.key_dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `value_dtype` attribute.
    pub fn value_dtype<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.value_dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `value_shape` attribute.
    pub fn value_shape<ArgType: ::std::convert::Into<crate::Shape>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.value_shape = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `AnonymousMutableHashTableOfTensors` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("AnonymousMutableHashTableOfTensors", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.key_dtype {
                nd.set_attr_type("key_dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.value_dtype {
                nd.set_attr_type("value_dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.value_shape {
                nd.set_attr_shape("value_shape", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'AnonymousMutableHashTableOfTensors' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        scope: &mut crate::Scope,
    ) -> crate::Result<AnonymousMutableHashTableOfTensorsInst> {
        let op = scope.new_operation("AnonymousMutableHashTableOfTensors", |builder| {
            if let ::std::option::Option::Some(value) = &self.key_dtype {
                builder.set_attr_type("key_dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.value_dtype {
                builder.set_attr_type("value_dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.value_shape {
                builder.set_attr_shape("value_shape", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(AnonymousMutableHashTableOfTensorsInst { op })
    }
}
impl AnonymousMutableHashTableOfTensorsInst {
    /// Returns the 'table_handle' Output of this 'AnonymousMutableHashTableOfTensors' operation.
    pub fn table_handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
}
impl From<AnonymousMutableHashTableOfTensorsInst> for crate::Operation {
    fn from(inst: AnonymousMutableHashTableOfTensorsInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `AnonymousMutableHashTableOfTensors::new().build(scope)`.
pub fn anonymous_mutable_hash_table_of_tensors(
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    AnonymousMutableHashTableOfTensors::new().build(scope)
}

/// Builder for the `AnonymousRandomSeedGenerator` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct AnonymousRandomSeedGenerator {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'AnonymousRandomSeedGenerator' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct AnonymousRandomSeedGeneratorInst {
    /// An instance of a fully built AnonymousRandomSeedGenerator Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl AnonymousRandomSeedGenerator {
    /// Creates a new `AnonymousRandomSeedGenerator`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `AnonymousRandomSeedGenerator` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        seed: O0,
        seed2: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(seed.into(), seed2.into(), scope)
    }
    fn build_impl(
        &self,
        seed: crate::Output,
        seed2: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("AnonymousRandomSeedGenerator", |nd| {
            nd.add_input(seed);
            nd.add_input(seed2);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'AnonymousRandomSeedGenerator' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        seed: crate::Output,
        seed2: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<AnonymousRandomSeedGeneratorInst> {
        let op = scope.new_operation("AnonymousRandomSeedGenerator", |builder| {
            builder.add_input(seed);
            builder.add_input(seed2);
            ::std::result::Result::Ok(())
        })?;
        Ok(AnonymousRandomSeedGeneratorInst { op })
    }
}
impl AnonymousRandomSeedGeneratorInst {
    /// Returns the 'handle' Output of this 'AnonymousRandomSeedGenerator' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'deleter' Output of this 'AnonymousRandomSeedGenerator' operation.
    pub fn deleter(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'seed' Input of this 'AnonymousRandomSeedGenerator' operation.
    pub fn seed(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'seed2' Input of this 'AnonymousRandomSeedGenerator' operation.
    pub fn seed2(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<AnonymousRandomSeedGeneratorInst> for crate::Operation {
    fn from(inst: AnonymousRandomSeedGeneratorInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `AnonymousRandomSeedGenerator::new().build(seed, seed2, scope)`.
pub fn anonymous_random_seed_generator<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    seed: O0,
    seed2: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    AnonymousRandomSeedGenerator::new().build(seed, seed2, scope)
}

/// Builder for the `AnonymousSeedGenerator` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct AnonymousSeedGenerator {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'AnonymousSeedGenerator' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct AnonymousSeedGeneratorInst {
    /// An instance of a fully built AnonymousSeedGenerator Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl AnonymousSeedGenerator {
    /// Creates a new `AnonymousSeedGenerator`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `AnonymousSeedGenerator` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        seed: O0,
        seed2: O1,
        reshuffle: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(seed.into(), seed2.into(), reshuffle.into(), scope)
    }
    fn build_impl(
        &self,
        seed: crate::Output,
        seed2: crate::Output,
        reshuffle: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("AnonymousSeedGenerator", |nd| {
            nd.add_input(seed);
            nd.add_input(seed2);
            nd.add_input(reshuffle);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'AnonymousSeedGenerator' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        seed: crate::Output,
        seed2: crate::Output,
        reshuffle: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<AnonymousSeedGeneratorInst> {
        let op = scope.new_operation("AnonymousSeedGenerator", |builder| {
            builder.add_input(seed);
            builder.add_input(seed2);
            builder.add_input(reshuffle);
            ::std::result::Result::Ok(())
        })?;
        Ok(AnonymousSeedGeneratorInst { op })
    }
}
impl AnonymousSeedGeneratorInst {
    /// Returns the 'handle' Output of this 'AnonymousSeedGenerator' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'deleter' Output of this 'AnonymousSeedGenerator' operation.
    pub fn deleter(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'seed' Input of this 'AnonymousSeedGenerator' operation.
    pub fn seed(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'seed2' Input of this 'AnonymousSeedGenerator' operation.
    pub fn seed2(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'reshuffle' Input of this 'AnonymousSeedGenerator' operation.
    pub fn reshuffle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<AnonymousSeedGeneratorInst> for crate::Operation {
    fn from(inst: AnonymousSeedGeneratorInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `AnonymousSeedGenerator::new().build(seed, seed2, reshuffle, scope)`.
pub fn anonymous_seed_generator<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    seed: O0,
    seed2: O1,
    reshuffle: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    AnonymousSeedGenerator::new().build(seed, seed2, reshuffle, scope)
}

/// Builder for the `Any` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Any {
    keep_dims: ::std::option::Option<bool>,
    Tidx: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Any' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct AnyInst {
    /// An instance of a fully built Any Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Any {
    /// Creates a new `Any`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `keep_dims` attribute.
    pub fn keep_dims<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.keep_dims = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tidx` attribute.
    pub fn Tidx<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Tidx = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Any` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        reduction_indices: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), reduction_indices.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        reduction_indices: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Any", |nd| {
            nd.add_input(input);
            nd.add_input(reduction_indices);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.keep_dims {
                nd.set_attr_bool("keep_dims", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tidx {
                nd.set_attr_type("Tidx", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Any' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        reduction_indices: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<AnyInst> {
        let op = scope.new_operation("Any", |builder| {
            builder.add_input(input);
            builder.add_input(reduction_indices);
            if let ::std::option::Option::Some(value) = &self.keep_dims {
                builder.set_attr_bool("keep_dims", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tidx {
                builder.set_attr_type("Tidx", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(AnyInst { op })
    }
}
impl AnyInst {
    /// Returns the 'output' Output of this 'Any' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'Any' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'reduction_indices' Input of this 'Any' operation.
    pub fn reduction_indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<AnyInst> for crate::Operation {
    fn from(inst: AnyInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Any::new().build(input, reduction_indices, scope)`.
pub fn any<O0: ::std::convert::Into<crate::Output>, O1: ::std::convert::Into<crate::Output>>(
    input: O0,
    reduction_indices: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Any::new().build(input, reduction_indices, scope)
}

/// Builder for the `ApplyAdaMax` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ApplyAdaMax {
    T: ::std::option::Option<crate::DataType>,
    use_locking: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ApplyAdaMax' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ApplyAdaMaxInst {
    /// An instance of a fully built ApplyAdaMax Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ApplyAdaMax {
    /// Creates a new `ApplyAdaMax`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_locking` attribute.
    pub fn use_locking<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.use_locking = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ApplyAdaMax` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
        O6: ::std::convert::Into<crate::Output>,
        O7: ::std::convert::Into<crate::Output>,
        O8: ::std::convert::Into<crate::Output>,
    >(
        &self,
        var: O0,
        m: O1,
        v: O2,
        beta1_power: O3,
        lr: O4,
        beta1: O5,
        beta2: O6,
        epsilon: O7,
        grad: O8,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            var.into(),
            m.into(),
            v.into(),
            beta1_power.into(),
            lr.into(),
            beta1.into(),
            beta2.into(),
            epsilon.into(),
            grad.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        var: crate::Output,
        m: crate::Output,
        v: crate::Output,
        beta1_power: crate::Output,
        lr: crate::Output,
        beta1: crate::Output,
        beta2: crate::Output,
        epsilon: crate::Output,
        grad: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ApplyAdaMax", |nd| {
            nd.add_input(var);
            nd.add_input(m);
            nd.add_input(v);
            nd.add_input(beta1_power);
            nd.add_input(lr);
            nd.add_input(beta1);
            nd.add_input(beta2);
            nd.add_input(epsilon);
            nd.add_input(grad);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                nd.set_attr_bool("use_locking", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ApplyAdaMax' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        var: crate::Output,
        m: crate::Output,
        v: crate::Output,
        beta1_power: crate::Output,
        lr: crate::Output,
        beta1: crate::Output,
        beta2: crate::Output,
        epsilon: crate::Output,
        grad: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ApplyAdaMaxInst> {
        let op = scope.new_operation("ApplyAdaMax", |builder| {
            builder.add_input(var);
            builder.add_input(m);
            builder.add_input(v);
            builder.add_input(beta1_power);
            builder.add_input(lr);
            builder.add_input(beta1);
            builder.add_input(beta2);
            builder.add_input(epsilon);
            builder.add_input(grad);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                builder.set_attr_bool("use_locking", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ApplyAdaMaxInst { op })
    }
}
impl ApplyAdaMaxInst {
    /// Returns the 'out' Output of this 'ApplyAdaMax' operation.
    pub fn out(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'var' Input of this 'ApplyAdaMax' operation.
    pub fn var(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'm' Input of this 'ApplyAdaMax' operation.
    pub fn m(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'v' Input of this 'ApplyAdaMax' operation.
    pub fn v(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'beta1_power' Input of this 'ApplyAdaMax' operation.
    pub fn beta1_power(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'lr' Input of this 'ApplyAdaMax' operation.
    pub fn lr(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
    /// Returns the 'beta1' Input of this 'ApplyAdaMax' operation.
    pub fn beta1(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 5,
        }
    }
    /// Returns the 'beta2' Input of this 'ApplyAdaMax' operation.
    pub fn beta2(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 6,
        }
    }
    /// Returns the 'epsilon' Input of this 'ApplyAdaMax' operation.
    pub fn epsilon(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 7,
        }
    }
    /// Returns the 'grad' Input of this 'ApplyAdaMax' operation.
    pub fn grad(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 8,
        }
    }
}
impl From<ApplyAdaMaxInst> for crate::Operation {
    fn from(inst: ApplyAdaMaxInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ApplyAdaMax::new().build(var, m, v, beta1_power, lr, beta1, beta2, epsilon, grad, scope)`.
pub fn apply_ada_max<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
    O6: ::std::convert::Into<crate::Output>,
    O7: ::std::convert::Into<crate::Output>,
    O8: ::std::convert::Into<crate::Output>,
>(
    var: O0,
    m: O1,
    v: O2,
    beta1_power: O3,
    lr: O4,
    beta1: O5,
    beta2: O6,
    epsilon: O7,
    grad: O8,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ApplyAdaMax::new().build(
        var,
        m,
        v,
        beta1_power,
        lr,
        beta1,
        beta2,
        epsilon,
        grad,
        scope,
    )
}

/// Builder for the `ApplyAdadelta` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ApplyAdadelta {
    T: ::std::option::Option<crate::DataType>,
    use_locking: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ApplyAdadelta' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ApplyAdadeltaInst {
    /// An instance of a fully built ApplyAdadelta Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ApplyAdadelta {
    /// Creates a new `ApplyAdadelta`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_locking` attribute.
    pub fn use_locking<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.use_locking = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ApplyAdadelta` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
        O6: ::std::convert::Into<crate::Output>,
    >(
        &self,
        var: O0,
        accum: O1,
        accum_update: O2,
        lr: O3,
        rho: O4,
        epsilon: O5,
        grad: O6,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            var.into(),
            accum.into(),
            accum_update.into(),
            lr.into(),
            rho.into(),
            epsilon.into(),
            grad.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        var: crate::Output,
        accum: crate::Output,
        accum_update: crate::Output,
        lr: crate::Output,
        rho: crate::Output,
        epsilon: crate::Output,
        grad: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ApplyAdadelta", |nd| {
            nd.add_input(var);
            nd.add_input(accum);
            nd.add_input(accum_update);
            nd.add_input(lr);
            nd.add_input(rho);
            nd.add_input(epsilon);
            nd.add_input(grad);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                nd.set_attr_bool("use_locking", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ApplyAdadelta' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        var: crate::Output,
        accum: crate::Output,
        accum_update: crate::Output,
        lr: crate::Output,
        rho: crate::Output,
        epsilon: crate::Output,
        grad: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ApplyAdadeltaInst> {
        let op = scope.new_operation("ApplyAdadelta", |builder| {
            builder.add_input(var);
            builder.add_input(accum);
            builder.add_input(accum_update);
            builder.add_input(lr);
            builder.add_input(rho);
            builder.add_input(epsilon);
            builder.add_input(grad);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                builder.set_attr_bool("use_locking", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ApplyAdadeltaInst { op })
    }
}
impl ApplyAdadeltaInst {
    /// Returns the 'out' Output of this 'ApplyAdadelta' operation.
    pub fn out(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'var' Input of this 'ApplyAdadelta' operation.
    pub fn var(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'accum' Input of this 'ApplyAdadelta' operation.
    pub fn accum(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'accum_update' Input of this 'ApplyAdadelta' operation.
    pub fn accum_update(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'lr' Input of this 'ApplyAdadelta' operation.
    pub fn lr(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'rho' Input of this 'ApplyAdadelta' operation.
    pub fn rho(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
    /// Returns the 'epsilon' Input of this 'ApplyAdadelta' operation.
    pub fn epsilon(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 5,
        }
    }
    /// Returns the 'grad' Input of this 'ApplyAdadelta' operation.
    pub fn grad(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 6,
        }
    }
}
impl From<ApplyAdadeltaInst> for crate::Operation {
    fn from(inst: ApplyAdadeltaInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ApplyAdadelta::new().build(var, accum, accum_update, lr, rho, epsilon, grad, scope)`.
pub fn apply_adadelta<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
    O6: ::std::convert::Into<crate::Output>,
>(
    var: O0,
    accum: O1,
    accum_update: O2,
    lr: O3,
    rho: O4,
    epsilon: O5,
    grad: O6,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ApplyAdadelta::new().build(var, accum, accum_update, lr, rho, epsilon, grad, scope)
}

/// Builder for the `ApplyAdagrad` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ApplyAdagrad {
    T: ::std::option::Option<crate::DataType>,
    use_locking: ::std::option::Option<bool>,
    update_slots: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ApplyAdagrad' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ApplyAdagradInst {
    /// An instance of a fully built ApplyAdagrad Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ApplyAdagrad {
    /// Creates a new `ApplyAdagrad`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_locking` attribute.
    pub fn use_locking<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.use_locking = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `update_slots` attribute.
    pub fn update_slots<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.update_slots = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ApplyAdagrad` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
    >(
        &self,
        var: O0,
        accum: O1,
        lr: O2,
        grad: O3,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(var.into(), accum.into(), lr.into(), grad.into(), scope)
    }
    fn build_impl(
        &self,
        var: crate::Output,
        accum: crate::Output,
        lr: crate::Output,
        grad: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ApplyAdagrad", |nd| {
            nd.add_input(var);
            nd.add_input(accum);
            nd.add_input(lr);
            nd.add_input(grad);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                nd.set_attr_bool("use_locking", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.update_slots {
                nd.set_attr_bool("update_slots", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ApplyAdagrad' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        var: crate::Output,
        accum: crate::Output,
        lr: crate::Output,
        grad: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ApplyAdagradInst> {
        let op = scope.new_operation("ApplyAdagrad", |builder| {
            builder.add_input(var);
            builder.add_input(accum);
            builder.add_input(lr);
            builder.add_input(grad);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                builder.set_attr_bool("use_locking", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.update_slots {
                builder.set_attr_bool("update_slots", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ApplyAdagradInst { op })
    }
}
impl ApplyAdagradInst {
    /// Returns the 'out' Output of this 'ApplyAdagrad' operation.
    pub fn out(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'var' Input of this 'ApplyAdagrad' operation.
    pub fn var(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'accum' Input of this 'ApplyAdagrad' operation.
    pub fn accum(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'lr' Input of this 'ApplyAdagrad' operation.
    pub fn lr(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'grad' Input of this 'ApplyAdagrad' operation.
    pub fn grad(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
}
impl From<ApplyAdagradInst> for crate::Operation {
    fn from(inst: ApplyAdagradInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ApplyAdagrad::new().build(var, accum, lr, grad, scope)`.
pub fn apply_adagrad<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
>(
    var: O0,
    accum: O1,
    lr: O2,
    grad: O3,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ApplyAdagrad::new().build(var, accum, lr, grad, scope)
}

/// Builder for the `ApplyAdagradDA` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ApplyAdagradDA {
    T: ::std::option::Option<crate::DataType>,
    use_locking: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ApplyAdagradDA' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ApplyAdagradDAInst {
    /// An instance of a fully built ApplyAdagradDA Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ApplyAdagradDA {
    /// Creates a new `ApplyAdagradDA`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_locking` attribute.
    pub fn use_locking<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.use_locking = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ApplyAdagradDA` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
        O6: ::std::convert::Into<crate::Output>,
        O7: ::std::convert::Into<crate::Output>,
    >(
        &self,
        var: O0,
        gradient_accumulator: O1,
        gradient_squared_accumulator: O2,
        grad: O3,
        lr: O4,
        l1: O5,
        l2: O6,
        global_step: O7,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            var.into(),
            gradient_accumulator.into(),
            gradient_squared_accumulator.into(),
            grad.into(),
            lr.into(),
            l1.into(),
            l2.into(),
            global_step.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        var: crate::Output,
        gradient_accumulator: crate::Output,
        gradient_squared_accumulator: crate::Output,
        grad: crate::Output,
        lr: crate::Output,
        l1: crate::Output,
        l2: crate::Output,
        global_step: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ApplyAdagradDA", |nd| {
            nd.add_input(var);
            nd.add_input(gradient_accumulator);
            nd.add_input(gradient_squared_accumulator);
            nd.add_input(grad);
            nd.add_input(lr);
            nd.add_input(l1);
            nd.add_input(l2);
            nd.add_input(global_step);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                nd.set_attr_bool("use_locking", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ApplyAdagradDA' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        var: crate::Output,
        gradient_accumulator: crate::Output,
        gradient_squared_accumulator: crate::Output,
        grad: crate::Output,
        lr: crate::Output,
        l1: crate::Output,
        l2: crate::Output,
        global_step: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ApplyAdagradDAInst> {
        let op = scope.new_operation("ApplyAdagradDA", |builder| {
            builder.add_input(var);
            builder.add_input(gradient_accumulator);
            builder.add_input(gradient_squared_accumulator);
            builder.add_input(grad);
            builder.add_input(lr);
            builder.add_input(l1);
            builder.add_input(l2);
            builder.add_input(global_step);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                builder.set_attr_bool("use_locking", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ApplyAdagradDAInst { op })
    }
}
impl ApplyAdagradDAInst {
    /// Returns the 'out' Output of this 'ApplyAdagradDA' operation.
    pub fn out(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'var' Input of this 'ApplyAdagradDA' operation.
    pub fn var(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'gradient_accumulator' Input of this 'ApplyAdagradDA' operation.
    pub fn gradient_accumulator(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'gradient_squared_accumulator' Input of this 'ApplyAdagradDA' operation.
    pub fn gradient_squared_accumulator(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'grad' Input of this 'ApplyAdagradDA' operation.
    pub fn grad(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'lr' Input of this 'ApplyAdagradDA' operation.
    pub fn lr(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
    /// Returns the 'l1' Input of this 'ApplyAdagradDA' operation.
    pub fn l1(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 5,
        }
    }
    /// Returns the 'l2' Input of this 'ApplyAdagradDA' operation.
    pub fn l2(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 6,
        }
    }
    /// Returns the 'global_step' Input of this 'ApplyAdagradDA' operation.
    pub fn global_step(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 7,
        }
    }
}
impl From<ApplyAdagradDAInst> for crate::Operation {
    fn from(inst: ApplyAdagradDAInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ApplyAdagradDA::new().build(var, gradient_accumulator, gradient_squared_accumulator, grad, lr, l1, l2, global_step, scope)`.
pub fn apply_adagrad_da<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
    O6: ::std::convert::Into<crate::Output>,
    O7: ::std::convert::Into<crate::Output>,
>(
    var: O0,
    gradient_accumulator: O1,
    gradient_squared_accumulator: O2,
    grad: O3,
    lr: O4,
    l1: O5,
    l2: O6,
    global_step: O7,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ApplyAdagradDA::new().build(
        var,
        gradient_accumulator,
        gradient_squared_accumulator,
        grad,
        lr,
        l1,
        l2,
        global_step,
        scope,
    )
}

/// Builder for the `ApplyAdagradV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ApplyAdagradV2 {
    T: ::std::option::Option<crate::DataType>,
    use_locking: ::std::option::Option<bool>,
    update_slots: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ApplyAdagradV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ApplyAdagradV2Inst {
    /// An instance of a fully built ApplyAdagradV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ApplyAdagradV2 {
    /// Creates a new `ApplyAdagradV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_locking` attribute.
    pub fn use_locking<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.use_locking = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `update_slots` attribute.
    pub fn update_slots<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.update_slots = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ApplyAdagradV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
    >(
        &self,
        var: O0,
        accum: O1,
        lr: O2,
        epsilon: O3,
        grad: O4,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            var.into(),
            accum.into(),
            lr.into(),
            epsilon.into(),
            grad.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        var: crate::Output,
        accum: crate::Output,
        lr: crate::Output,
        epsilon: crate::Output,
        grad: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ApplyAdagradV2", |nd| {
            nd.add_input(var);
            nd.add_input(accum);
            nd.add_input(lr);
            nd.add_input(epsilon);
            nd.add_input(grad);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                nd.set_attr_bool("use_locking", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.update_slots {
                nd.set_attr_bool("update_slots", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ApplyAdagradV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        var: crate::Output,
        accum: crate::Output,
        lr: crate::Output,
        epsilon: crate::Output,
        grad: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ApplyAdagradV2Inst> {
        let op = scope.new_operation("ApplyAdagradV2", |builder| {
            builder.add_input(var);
            builder.add_input(accum);
            builder.add_input(lr);
            builder.add_input(epsilon);
            builder.add_input(grad);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                builder.set_attr_bool("use_locking", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.update_slots {
                builder.set_attr_bool("update_slots", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ApplyAdagradV2Inst { op })
    }
}
impl ApplyAdagradV2Inst {
    /// Returns the 'out' Output of this 'ApplyAdagradV2' operation.
    pub fn out(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'var' Input of this 'ApplyAdagradV2' operation.
    pub fn var(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'accum' Input of this 'ApplyAdagradV2' operation.
    pub fn accum(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'lr' Input of this 'ApplyAdagradV2' operation.
    pub fn lr(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'epsilon' Input of this 'ApplyAdagradV2' operation.
    pub fn epsilon(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'grad' Input of this 'ApplyAdagradV2' operation.
    pub fn grad(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
}
impl From<ApplyAdagradV2Inst> for crate::Operation {
    fn from(inst: ApplyAdagradV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ApplyAdagradV2::new().build(var, accum, lr, epsilon, grad, scope)`.
pub fn apply_adagrad_v2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
>(
    var: O0,
    accum: O1,
    lr: O2,
    epsilon: O3,
    grad: O4,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ApplyAdagradV2::new().build(var, accum, lr, epsilon, grad, scope)
}

/// Builder for the `ApplyAdam` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ApplyAdam {
    T: ::std::option::Option<crate::DataType>,
    use_locking: ::std::option::Option<bool>,
    use_nesterov: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ApplyAdam' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ApplyAdamInst {
    /// An instance of a fully built ApplyAdam Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ApplyAdam {
    /// Creates a new `ApplyAdam`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_locking` attribute.
    pub fn use_locking<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.use_locking = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_nesterov` attribute.
    pub fn use_nesterov<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.use_nesterov = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ApplyAdam` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
        O6: ::std::convert::Into<crate::Output>,
        O7: ::std::convert::Into<crate::Output>,
        O8: ::std::convert::Into<crate::Output>,
        O9: ::std::convert::Into<crate::Output>,
    >(
        &self,
        var: O0,
        m: O1,
        v: O2,
        beta1_power: O3,
        beta2_power: O4,
        lr: O5,
        beta1: O6,
        beta2: O7,
        epsilon: O8,
        grad: O9,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            var.into(),
            m.into(),
            v.into(),
            beta1_power.into(),
            beta2_power.into(),
            lr.into(),
            beta1.into(),
            beta2.into(),
            epsilon.into(),
            grad.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        var: crate::Output,
        m: crate::Output,
        v: crate::Output,
        beta1_power: crate::Output,
        beta2_power: crate::Output,
        lr: crate::Output,
        beta1: crate::Output,
        beta2: crate::Output,
        epsilon: crate::Output,
        grad: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ApplyAdam", |nd| {
            nd.add_input(var);
            nd.add_input(m);
            nd.add_input(v);
            nd.add_input(beta1_power);
            nd.add_input(beta2_power);
            nd.add_input(lr);
            nd.add_input(beta1);
            nd.add_input(beta2);
            nd.add_input(epsilon);
            nd.add_input(grad);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                nd.set_attr_bool("use_locking", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_nesterov {
                nd.set_attr_bool("use_nesterov", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ApplyAdam' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        var: crate::Output,
        m: crate::Output,
        v: crate::Output,
        beta1_power: crate::Output,
        beta2_power: crate::Output,
        lr: crate::Output,
        beta1: crate::Output,
        beta2: crate::Output,
        epsilon: crate::Output,
        grad: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ApplyAdamInst> {
        let op = scope.new_operation("ApplyAdam", |builder| {
            builder.add_input(var);
            builder.add_input(m);
            builder.add_input(v);
            builder.add_input(beta1_power);
            builder.add_input(beta2_power);
            builder.add_input(lr);
            builder.add_input(beta1);
            builder.add_input(beta2);
            builder.add_input(epsilon);
            builder.add_input(grad);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                builder.set_attr_bool("use_locking", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_nesterov {
                builder.set_attr_bool("use_nesterov", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ApplyAdamInst { op })
    }
}
impl ApplyAdamInst {
    /// Returns the 'out' Output of this 'ApplyAdam' operation.
    pub fn out(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'var' Input of this 'ApplyAdam' operation.
    pub fn var(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'm' Input of this 'ApplyAdam' operation.
    pub fn m(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'v' Input of this 'ApplyAdam' operation.
    pub fn v(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'beta1_power' Input of this 'ApplyAdam' operation.
    pub fn beta1_power(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'beta2_power' Input of this 'ApplyAdam' operation.
    pub fn beta2_power(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
    /// Returns the 'lr' Input of this 'ApplyAdam' operation.
    pub fn lr(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 5,
        }
    }
    /// Returns the 'beta1' Input of this 'ApplyAdam' operation.
    pub fn beta1(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 6,
        }
    }
    /// Returns the 'beta2' Input of this 'ApplyAdam' operation.
    pub fn beta2(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 7,
        }
    }
    /// Returns the 'epsilon' Input of this 'ApplyAdam' operation.
    pub fn epsilon(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 8,
        }
    }
    /// Returns the 'grad' Input of this 'ApplyAdam' operation.
    pub fn grad(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 9,
        }
    }
}
impl From<ApplyAdamInst> for crate::Operation {
    fn from(inst: ApplyAdamInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ApplyAdam::new().build(var, m, v, beta1_power, beta2_power, lr, beta1, beta2, epsilon, grad, scope)`.
pub fn apply_adam<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
    O6: ::std::convert::Into<crate::Output>,
    O7: ::std::convert::Into<crate::Output>,
    O8: ::std::convert::Into<crate::Output>,
    O9: ::std::convert::Into<crate::Output>,
>(
    var: O0,
    m: O1,
    v: O2,
    beta1_power: O3,
    beta2_power: O4,
    lr: O5,
    beta1: O6,
    beta2: O7,
    epsilon: O8,
    grad: O9,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ApplyAdam::new().build(
        var,
        m,
        v,
        beta1_power,
        beta2_power,
        lr,
        beta1,
        beta2,
        epsilon,
        grad,
        scope,
    )
}

/// Builder for the `ApplyAddSign` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ApplyAddSign {
    T: ::std::option::Option<crate::DataType>,
    use_locking: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ApplyAddSign' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ApplyAddSignInst {
    /// An instance of a fully built ApplyAddSign Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ApplyAddSign {
    /// Creates a new `ApplyAddSign`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_locking` attribute.
    pub fn use_locking<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.use_locking = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ApplyAddSign` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
        O6: ::std::convert::Into<crate::Output>,
    >(
        &self,
        var: O0,
        m: O1,
        lr: O2,
        alpha: O3,
        sign_decay: O4,
        beta: O5,
        grad: O6,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            var.into(),
            m.into(),
            lr.into(),
            alpha.into(),
            sign_decay.into(),
            beta.into(),
            grad.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        var: crate::Output,
        m: crate::Output,
        lr: crate::Output,
        alpha: crate::Output,
        sign_decay: crate::Output,
        beta: crate::Output,
        grad: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ApplyAddSign", |nd| {
            nd.add_input(var);
            nd.add_input(m);
            nd.add_input(lr);
            nd.add_input(alpha);
            nd.add_input(sign_decay);
            nd.add_input(beta);
            nd.add_input(grad);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                nd.set_attr_bool("use_locking", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ApplyAddSign' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        var: crate::Output,
        m: crate::Output,
        lr: crate::Output,
        alpha: crate::Output,
        sign_decay: crate::Output,
        beta: crate::Output,
        grad: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ApplyAddSignInst> {
        let op = scope.new_operation("ApplyAddSign", |builder| {
            builder.add_input(var);
            builder.add_input(m);
            builder.add_input(lr);
            builder.add_input(alpha);
            builder.add_input(sign_decay);
            builder.add_input(beta);
            builder.add_input(grad);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                builder.set_attr_bool("use_locking", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ApplyAddSignInst { op })
    }
}
impl ApplyAddSignInst {
    /// Returns the 'out' Output of this 'ApplyAddSign' operation.
    pub fn out(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'var' Input of this 'ApplyAddSign' operation.
    pub fn var(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'm' Input of this 'ApplyAddSign' operation.
    pub fn m(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'lr' Input of this 'ApplyAddSign' operation.
    pub fn lr(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'alpha' Input of this 'ApplyAddSign' operation.
    pub fn alpha(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'sign_decay' Input of this 'ApplyAddSign' operation.
    pub fn sign_decay(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
    /// Returns the 'beta' Input of this 'ApplyAddSign' operation.
    pub fn beta(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 5,
        }
    }
    /// Returns the 'grad' Input of this 'ApplyAddSign' operation.
    pub fn grad(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 6,
        }
    }
}
impl From<ApplyAddSignInst> for crate::Operation {
    fn from(inst: ApplyAddSignInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ApplyAddSign::new().build(var, m, lr, alpha, sign_decay, beta, grad, scope)`.
pub fn apply_add_sign<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
    O6: ::std::convert::Into<crate::Output>,
>(
    var: O0,
    m: O1,
    lr: O2,
    alpha: O3,
    sign_decay: O4,
    beta: O5,
    grad: O6,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ApplyAddSign::new().build(var, m, lr, alpha, sign_decay, beta, grad, scope)
}

/// Builder for the `ApplyCenteredRMSProp` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ApplyCenteredRMSProp {
    T: ::std::option::Option<crate::DataType>,
    use_locking: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ApplyCenteredRMSProp' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ApplyCenteredRMSPropInst {
    /// An instance of a fully built ApplyCenteredRMSProp Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ApplyCenteredRMSProp {
    /// Creates a new `ApplyCenteredRMSProp`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_locking` attribute.
    pub fn use_locking<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.use_locking = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ApplyCenteredRMSProp` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
        O6: ::std::convert::Into<crate::Output>,
        O7: ::std::convert::Into<crate::Output>,
        O8: ::std::convert::Into<crate::Output>,
    >(
        &self,
        var: O0,
        mg: O1,
        ms: O2,
        mom: O3,
        lr: O4,
        rho: O5,
        momentum: O6,
        epsilon: O7,
        grad: O8,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            var.into(),
            mg.into(),
            ms.into(),
            mom.into(),
            lr.into(),
            rho.into(),
            momentum.into(),
            epsilon.into(),
            grad.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        var: crate::Output,
        mg: crate::Output,
        ms: crate::Output,
        mom: crate::Output,
        lr: crate::Output,
        rho: crate::Output,
        momentum: crate::Output,
        epsilon: crate::Output,
        grad: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ApplyCenteredRMSProp", |nd| {
            nd.add_input(var);
            nd.add_input(mg);
            nd.add_input(ms);
            nd.add_input(mom);
            nd.add_input(lr);
            nd.add_input(rho);
            nd.add_input(momentum);
            nd.add_input(epsilon);
            nd.add_input(grad);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                nd.set_attr_bool("use_locking", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ApplyCenteredRMSProp' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        var: crate::Output,
        mg: crate::Output,
        ms: crate::Output,
        mom: crate::Output,
        lr: crate::Output,
        rho: crate::Output,
        momentum: crate::Output,
        epsilon: crate::Output,
        grad: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ApplyCenteredRMSPropInst> {
        let op = scope.new_operation("ApplyCenteredRMSProp", |builder| {
            builder.add_input(var);
            builder.add_input(mg);
            builder.add_input(ms);
            builder.add_input(mom);
            builder.add_input(lr);
            builder.add_input(rho);
            builder.add_input(momentum);
            builder.add_input(epsilon);
            builder.add_input(grad);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                builder.set_attr_bool("use_locking", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ApplyCenteredRMSPropInst { op })
    }
}
impl ApplyCenteredRMSPropInst {
    /// Returns the 'out' Output of this 'ApplyCenteredRMSProp' operation.
    pub fn out(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'var' Input of this 'ApplyCenteredRMSProp' operation.
    pub fn var(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'mg' Input of this 'ApplyCenteredRMSProp' operation.
    pub fn mg(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'ms' Input of this 'ApplyCenteredRMSProp' operation.
    pub fn ms(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'mom' Input of this 'ApplyCenteredRMSProp' operation.
    pub fn mom(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'lr' Input of this 'ApplyCenteredRMSProp' operation.
    pub fn lr(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
    /// Returns the 'rho' Input of this 'ApplyCenteredRMSProp' operation.
    pub fn rho(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 5,
        }
    }
    /// Returns the 'momentum' Input of this 'ApplyCenteredRMSProp' operation.
    pub fn momentum(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 6,
        }
    }
    /// Returns the 'epsilon' Input of this 'ApplyCenteredRMSProp' operation.
    pub fn epsilon(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 7,
        }
    }
    /// Returns the 'grad' Input of this 'ApplyCenteredRMSProp' operation.
    pub fn grad(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 8,
        }
    }
}
impl From<ApplyCenteredRMSPropInst> for crate::Operation {
    fn from(inst: ApplyCenteredRMSPropInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ApplyCenteredRMSProp::new().build(var, mg, ms, mom, lr, rho, momentum, epsilon, grad, scope)`.
pub fn apply_centered_rmsprop<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
    O6: ::std::convert::Into<crate::Output>,
    O7: ::std::convert::Into<crate::Output>,
    O8: ::std::convert::Into<crate::Output>,
>(
    var: O0,
    mg: O1,
    ms: O2,
    mom: O3,
    lr: O4,
    rho: O5,
    momentum: O6,
    epsilon: O7,
    grad: O8,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ApplyCenteredRMSProp::new().build(var, mg, ms, mom, lr, rho, momentum, epsilon, grad, scope)
}

/// Builder for the `ApplyFtrl` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ApplyFtrl {
    T: ::std::option::Option<crate::DataType>,
    use_locking: ::std::option::Option<bool>,
    multiply_linear_by_lr: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ApplyFtrl' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ApplyFtrlInst {
    /// An instance of a fully built ApplyFtrl Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ApplyFtrl {
    /// Creates a new `ApplyFtrl`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_locking` attribute.
    pub fn use_locking<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.use_locking = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `multiply_linear_by_lr` attribute.
    pub fn multiply_linear_by_lr<ArgType: ::std::convert::Into<bool>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.multiply_linear_by_lr = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ApplyFtrl` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
        O6: ::std::convert::Into<crate::Output>,
        O7: ::std::convert::Into<crate::Output>,
    >(
        &self,
        var: O0,
        accum: O1,
        linear: O2,
        grad: O3,
        lr: O4,
        l1: O5,
        l2: O6,
        lr_power: O7,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            var.into(),
            accum.into(),
            linear.into(),
            grad.into(),
            lr.into(),
            l1.into(),
            l2.into(),
            lr_power.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        var: crate::Output,
        accum: crate::Output,
        linear: crate::Output,
        grad: crate::Output,
        lr: crate::Output,
        l1: crate::Output,
        l2: crate::Output,
        lr_power: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ApplyFtrl", |nd| {
            nd.add_input(var);
            nd.add_input(accum);
            nd.add_input(linear);
            nd.add_input(grad);
            nd.add_input(lr);
            nd.add_input(l1);
            nd.add_input(l2);
            nd.add_input(lr_power);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                nd.set_attr_bool("use_locking", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.multiply_linear_by_lr {
                nd.set_attr_bool("multiply_linear_by_lr", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ApplyFtrl' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        var: crate::Output,
        accum: crate::Output,
        linear: crate::Output,
        grad: crate::Output,
        lr: crate::Output,
        l1: crate::Output,
        l2: crate::Output,
        lr_power: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ApplyFtrlInst> {
        let op = scope.new_operation("ApplyFtrl", |builder| {
            builder.add_input(var);
            builder.add_input(accum);
            builder.add_input(linear);
            builder.add_input(grad);
            builder.add_input(lr);
            builder.add_input(l1);
            builder.add_input(l2);
            builder.add_input(lr_power);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                builder.set_attr_bool("use_locking", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.multiply_linear_by_lr {
                builder.set_attr_bool("multiply_linear_by_lr", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ApplyFtrlInst { op })
    }
}
impl ApplyFtrlInst {
    /// Returns the 'out' Output of this 'ApplyFtrl' operation.
    pub fn out(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'var' Input of this 'ApplyFtrl' operation.
    pub fn var(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'accum' Input of this 'ApplyFtrl' operation.
    pub fn accum(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'linear' Input of this 'ApplyFtrl' operation.
    pub fn linear(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'grad' Input of this 'ApplyFtrl' operation.
    pub fn grad(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'lr' Input of this 'ApplyFtrl' operation.
    pub fn lr(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
    /// Returns the 'l1' Input of this 'ApplyFtrl' operation.
    pub fn l1(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 5,
        }
    }
    /// Returns the 'l2' Input of this 'ApplyFtrl' operation.
    pub fn l2(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 6,
        }
    }
    /// Returns the 'lr_power' Input of this 'ApplyFtrl' operation.
    pub fn lr_power(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 7,
        }
    }
}
impl From<ApplyFtrlInst> for crate::Operation {
    fn from(inst: ApplyFtrlInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ApplyFtrl::new().build(var, accum, linear, grad, lr, l1, l2, lr_power, scope)`.
pub fn apply_ftrl<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
    O6: ::std::convert::Into<crate::Output>,
    O7: ::std::convert::Into<crate::Output>,
>(
    var: O0,
    accum: O1,
    linear: O2,
    grad: O3,
    lr: O4,
    l1: O5,
    l2: O6,
    lr_power: O7,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ApplyFtrl::new().build(var, accum, linear, grad, lr, l1, l2, lr_power, scope)
}

/// Builder for the `ApplyFtrlV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ApplyFtrlV2 {
    T: ::std::option::Option<crate::DataType>,
    use_locking: ::std::option::Option<bool>,
    multiply_linear_by_lr: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ApplyFtrlV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ApplyFtrlV2Inst {
    /// An instance of a fully built ApplyFtrlV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ApplyFtrlV2 {
    /// Creates a new `ApplyFtrlV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_locking` attribute.
    pub fn use_locking<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.use_locking = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `multiply_linear_by_lr` attribute.
    pub fn multiply_linear_by_lr<ArgType: ::std::convert::Into<bool>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.multiply_linear_by_lr = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ApplyFtrlV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
        O6: ::std::convert::Into<crate::Output>,
        O7: ::std::convert::Into<crate::Output>,
        O8: ::std::convert::Into<crate::Output>,
    >(
        &self,
        var: O0,
        accum: O1,
        linear: O2,
        grad: O3,
        lr: O4,
        l1: O5,
        l2: O6,
        l2_shrinkage: O7,
        lr_power: O8,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            var.into(),
            accum.into(),
            linear.into(),
            grad.into(),
            lr.into(),
            l1.into(),
            l2.into(),
            l2_shrinkage.into(),
            lr_power.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        var: crate::Output,
        accum: crate::Output,
        linear: crate::Output,
        grad: crate::Output,
        lr: crate::Output,
        l1: crate::Output,
        l2: crate::Output,
        l2_shrinkage: crate::Output,
        lr_power: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ApplyFtrlV2", |nd| {
            nd.add_input(var);
            nd.add_input(accum);
            nd.add_input(linear);
            nd.add_input(grad);
            nd.add_input(lr);
            nd.add_input(l1);
            nd.add_input(l2);
            nd.add_input(l2_shrinkage);
            nd.add_input(lr_power);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                nd.set_attr_bool("use_locking", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.multiply_linear_by_lr {
                nd.set_attr_bool("multiply_linear_by_lr", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ApplyFtrlV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        var: crate::Output,
        accum: crate::Output,
        linear: crate::Output,
        grad: crate::Output,
        lr: crate::Output,
        l1: crate::Output,
        l2: crate::Output,
        l2_shrinkage: crate::Output,
        lr_power: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ApplyFtrlV2Inst> {
        let op = scope.new_operation("ApplyFtrlV2", |builder| {
            builder.add_input(var);
            builder.add_input(accum);
            builder.add_input(linear);
            builder.add_input(grad);
            builder.add_input(lr);
            builder.add_input(l1);
            builder.add_input(l2);
            builder.add_input(l2_shrinkage);
            builder.add_input(lr_power);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                builder.set_attr_bool("use_locking", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.multiply_linear_by_lr {
                builder.set_attr_bool("multiply_linear_by_lr", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ApplyFtrlV2Inst { op })
    }
}
impl ApplyFtrlV2Inst {
    /// Returns the 'out' Output of this 'ApplyFtrlV2' operation.
    pub fn out(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'var' Input of this 'ApplyFtrlV2' operation.
    pub fn var(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'accum' Input of this 'ApplyFtrlV2' operation.
    pub fn accum(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'linear' Input of this 'ApplyFtrlV2' operation.
    pub fn linear(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'grad' Input of this 'ApplyFtrlV2' operation.
    pub fn grad(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'lr' Input of this 'ApplyFtrlV2' operation.
    pub fn lr(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
    /// Returns the 'l1' Input of this 'ApplyFtrlV2' operation.
    pub fn l1(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 5,
        }
    }
    /// Returns the 'l2' Input of this 'ApplyFtrlV2' operation.
    pub fn l2(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 6,
        }
    }
    /// Returns the 'l2_shrinkage' Input of this 'ApplyFtrlV2' operation.
    pub fn l2_shrinkage(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 7,
        }
    }
    /// Returns the 'lr_power' Input of this 'ApplyFtrlV2' operation.
    pub fn lr_power(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 8,
        }
    }
}
impl From<ApplyFtrlV2Inst> for crate::Operation {
    fn from(inst: ApplyFtrlV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ApplyFtrlV2::new().build(var, accum, linear, grad, lr, l1, l2, l2_shrinkage, lr_power, scope)`.
pub fn apply_ftrl_v2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
    O6: ::std::convert::Into<crate::Output>,
    O7: ::std::convert::Into<crate::Output>,
    O8: ::std::convert::Into<crate::Output>,
>(
    var: O0,
    accum: O1,
    linear: O2,
    grad: O3,
    lr: O4,
    l1: O5,
    l2: O6,
    l2_shrinkage: O7,
    lr_power: O8,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ApplyFtrlV2::new().build(
        var,
        accum,
        linear,
        grad,
        lr,
        l1,
        l2,
        l2_shrinkage,
        lr_power,
        scope,
    )
}

/// Builder for the `ApplyGradientDescent` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ApplyGradientDescent {
    T: ::std::option::Option<crate::DataType>,
    use_locking: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ApplyGradientDescent' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ApplyGradientDescentInst {
    /// An instance of a fully built ApplyGradientDescent Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ApplyGradientDescent {
    /// Creates a new `ApplyGradientDescent`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_locking` attribute.
    pub fn use_locking<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.use_locking = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ApplyGradientDescent` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        var: O0,
        alpha: O1,
        delta: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(var.into(), alpha.into(), delta.into(), scope)
    }
    fn build_impl(
        &self,
        var: crate::Output,
        alpha: crate::Output,
        delta: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ApplyGradientDescent", |nd| {
            nd.add_input(var);
            nd.add_input(alpha);
            nd.add_input(delta);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                nd.set_attr_bool("use_locking", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ApplyGradientDescent' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        var: crate::Output,
        alpha: crate::Output,
        delta: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ApplyGradientDescentInst> {
        let op = scope.new_operation("ApplyGradientDescent", |builder| {
            builder.add_input(var);
            builder.add_input(alpha);
            builder.add_input(delta);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                builder.set_attr_bool("use_locking", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ApplyGradientDescentInst { op })
    }
}
impl ApplyGradientDescentInst {
    /// Returns the 'out' Output of this 'ApplyGradientDescent' operation.
    pub fn out(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'var' Input of this 'ApplyGradientDescent' operation.
    pub fn var(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'alpha' Input of this 'ApplyGradientDescent' operation.
    pub fn alpha(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'delta' Input of this 'ApplyGradientDescent' operation.
    pub fn delta(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<ApplyGradientDescentInst> for crate::Operation {
    fn from(inst: ApplyGradientDescentInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ApplyGradientDescent::new().build(var, alpha, delta, scope)`.
pub fn apply_gradient_descent<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    var: O0,
    alpha: O1,
    delta: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ApplyGradientDescent::new().build(var, alpha, delta, scope)
}

/// Builder for the `ApplyMomentum` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ApplyMomentum {
    T: ::std::option::Option<crate::DataType>,
    use_locking: ::std::option::Option<bool>,
    use_nesterov: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ApplyMomentum' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ApplyMomentumInst {
    /// An instance of a fully built ApplyMomentum Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ApplyMomentum {
    /// Creates a new `ApplyMomentum`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_locking` attribute.
    pub fn use_locking<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.use_locking = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_nesterov` attribute.
    pub fn use_nesterov<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.use_nesterov = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ApplyMomentum` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
    >(
        &self,
        var: O0,
        accum: O1,
        lr: O2,
        grad: O3,
        momentum: O4,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            var.into(),
            accum.into(),
            lr.into(),
            grad.into(),
            momentum.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        var: crate::Output,
        accum: crate::Output,
        lr: crate::Output,
        grad: crate::Output,
        momentum: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ApplyMomentum", |nd| {
            nd.add_input(var);
            nd.add_input(accum);
            nd.add_input(lr);
            nd.add_input(grad);
            nd.add_input(momentum);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                nd.set_attr_bool("use_locking", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_nesterov {
                nd.set_attr_bool("use_nesterov", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ApplyMomentum' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        var: crate::Output,
        accum: crate::Output,
        lr: crate::Output,
        grad: crate::Output,
        momentum: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ApplyMomentumInst> {
        let op = scope.new_operation("ApplyMomentum", |builder| {
            builder.add_input(var);
            builder.add_input(accum);
            builder.add_input(lr);
            builder.add_input(grad);
            builder.add_input(momentum);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                builder.set_attr_bool("use_locking", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_nesterov {
                builder.set_attr_bool("use_nesterov", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ApplyMomentumInst { op })
    }
}
impl ApplyMomentumInst {
    /// Returns the 'out' Output of this 'ApplyMomentum' operation.
    pub fn out(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'var' Input of this 'ApplyMomentum' operation.
    pub fn var(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'accum' Input of this 'ApplyMomentum' operation.
    pub fn accum(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'lr' Input of this 'ApplyMomentum' operation.
    pub fn lr(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'grad' Input of this 'ApplyMomentum' operation.
    pub fn grad(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'momentum' Input of this 'ApplyMomentum' operation.
    pub fn momentum(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
}
impl From<ApplyMomentumInst> for crate::Operation {
    fn from(inst: ApplyMomentumInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ApplyMomentum::new().build(var, accum, lr, grad, momentum, scope)`.
pub fn apply_momentum<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
>(
    var: O0,
    accum: O1,
    lr: O2,
    grad: O3,
    momentum: O4,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ApplyMomentum::new().build(var, accum, lr, grad, momentum, scope)
}

/// Builder for the `ApplyPowerSign` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ApplyPowerSign {
    T: ::std::option::Option<crate::DataType>,
    use_locking: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ApplyPowerSign' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ApplyPowerSignInst {
    /// An instance of a fully built ApplyPowerSign Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ApplyPowerSign {
    /// Creates a new `ApplyPowerSign`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_locking` attribute.
    pub fn use_locking<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.use_locking = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ApplyPowerSign` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
        O6: ::std::convert::Into<crate::Output>,
    >(
        &self,
        var: O0,
        m: O1,
        lr: O2,
        logbase: O3,
        sign_decay: O4,
        beta: O5,
        grad: O6,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            var.into(),
            m.into(),
            lr.into(),
            logbase.into(),
            sign_decay.into(),
            beta.into(),
            grad.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        var: crate::Output,
        m: crate::Output,
        lr: crate::Output,
        logbase: crate::Output,
        sign_decay: crate::Output,
        beta: crate::Output,
        grad: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ApplyPowerSign", |nd| {
            nd.add_input(var);
            nd.add_input(m);
            nd.add_input(lr);
            nd.add_input(logbase);
            nd.add_input(sign_decay);
            nd.add_input(beta);
            nd.add_input(grad);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                nd.set_attr_bool("use_locking", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ApplyPowerSign' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        var: crate::Output,
        m: crate::Output,
        lr: crate::Output,
        logbase: crate::Output,
        sign_decay: crate::Output,
        beta: crate::Output,
        grad: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ApplyPowerSignInst> {
        let op = scope.new_operation("ApplyPowerSign", |builder| {
            builder.add_input(var);
            builder.add_input(m);
            builder.add_input(lr);
            builder.add_input(logbase);
            builder.add_input(sign_decay);
            builder.add_input(beta);
            builder.add_input(grad);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                builder.set_attr_bool("use_locking", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ApplyPowerSignInst { op })
    }
}
impl ApplyPowerSignInst {
    /// Returns the 'out' Output of this 'ApplyPowerSign' operation.
    pub fn out(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'var' Input of this 'ApplyPowerSign' operation.
    pub fn var(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'm' Input of this 'ApplyPowerSign' operation.
    pub fn m(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'lr' Input of this 'ApplyPowerSign' operation.
    pub fn lr(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'logbase' Input of this 'ApplyPowerSign' operation.
    pub fn logbase(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'sign_decay' Input of this 'ApplyPowerSign' operation.
    pub fn sign_decay(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
    /// Returns the 'beta' Input of this 'ApplyPowerSign' operation.
    pub fn beta(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 5,
        }
    }
    /// Returns the 'grad' Input of this 'ApplyPowerSign' operation.
    pub fn grad(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 6,
        }
    }
}
impl From<ApplyPowerSignInst> for crate::Operation {
    fn from(inst: ApplyPowerSignInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ApplyPowerSign::new().build(var, m, lr, logbase, sign_decay, beta, grad, scope)`.
pub fn apply_power_sign<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
    O6: ::std::convert::Into<crate::Output>,
>(
    var: O0,
    m: O1,
    lr: O2,
    logbase: O3,
    sign_decay: O4,
    beta: O5,
    grad: O6,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ApplyPowerSign::new().build(var, m, lr, logbase, sign_decay, beta, grad, scope)
}

/// Builder for the `ApplyProximalAdagrad` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ApplyProximalAdagrad {
    T: ::std::option::Option<crate::DataType>,
    use_locking: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ApplyProximalAdagrad' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ApplyProximalAdagradInst {
    /// An instance of a fully built ApplyProximalAdagrad Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ApplyProximalAdagrad {
    /// Creates a new `ApplyProximalAdagrad`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_locking` attribute.
    pub fn use_locking<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.use_locking = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ApplyProximalAdagrad` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
    >(
        &self,
        var: O0,
        accum: O1,
        lr: O2,
        l1: O3,
        l2: O4,
        grad: O5,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            var.into(),
            accum.into(),
            lr.into(),
            l1.into(),
            l2.into(),
            grad.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        var: crate::Output,
        accum: crate::Output,
        lr: crate::Output,
        l1: crate::Output,
        l2: crate::Output,
        grad: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ApplyProximalAdagrad", |nd| {
            nd.add_input(var);
            nd.add_input(accum);
            nd.add_input(lr);
            nd.add_input(l1);
            nd.add_input(l2);
            nd.add_input(grad);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                nd.set_attr_bool("use_locking", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ApplyProximalAdagrad' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        var: crate::Output,
        accum: crate::Output,
        lr: crate::Output,
        l1: crate::Output,
        l2: crate::Output,
        grad: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ApplyProximalAdagradInst> {
        let op = scope.new_operation("ApplyProximalAdagrad", |builder| {
            builder.add_input(var);
            builder.add_input(accum);
            builder.add_input(lr);
            builder.add_input(l1);
            builder.add_input(l2);
            builder.add_input(grad);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                builder.set_attr_bool("use_locking", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ApplyProximalAdagradInst { op })
    }
}
impl ApplyProximalAdagradInst {
    /// Returns the 'out' Output of this 'ApplyProximalAdagrad' operation.
    pub fn out(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'var' Input of this 'ApplyProximalAdagrad' operation.
    pub fn var(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'accum' Input of this 'ApplyProximalAdagrad' operation.
    pub fn accum(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'lr' Input of this 'ApplyProximalAdagrad' operation.
    pub fn lr(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'l1' Input of this 'ApplyProximalAdagrad' operation.
    pub fn l1(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'l2' Input of this 'ApplyProximalAdagrad' operation.
    pub fn l2(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
    /// Returns the 'grad' Input of this 'ApplyProximalAdagrad' operation.
    pub fn grad(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 5,
        }
    }
}
impl From<ApplyProximalAdagradInst> for crate::Operation {
    fn from(inst: ApplyProximalAdagradInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ApplyProximalAdagrad::new().build(var, accum, lr, l1, l2, grad, scope)`.
pub fn apply_proximal_adagrad<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
>(
    var: O0,
    accum: O1,
    lr: O2,
    l1: O3,
    l2: O4,
    grad: O5,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ApplyProximalAdagrad::new().build(var, accum, lr, l1, l2, grad, scope)
}

/// Builder for the `ApplyProximalGradientDescent` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ApplyProximalGradientDescent {
    T: ::std::option::Option<crate::DataType>,
    use_locking: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ApplyProximalGradientDescent' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ApplyProximalGradientDescentInst {
    /// An instance of a fully built ApplyProximalGradientDescent Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ApplyProximalGradientDescent {
    /// Creates a new `ApplyProximalGradientDescent`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_locking` attribute.
    pub fn use_locking<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.use_locking = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ApplyProximalGradientDescent` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
    >(
        &self,
        var: O0,
        alpha: O1,
        l1: O2,
        l2: O3,
        delta: O4,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            var.into(),
            alpha.into(),
            l1.into(),
            l2.into(),
            delta.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        var: crate::Output,
        alpha: crate::Output,
        l1: crate::Output,
        l2: crate::Output,
        delta: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ApplyProximalGradientDescent", |nd| {
            nd.add_input(var);
            nd.add_input(alpha);
            nd.add_input(l1);
            nd.add_input(l2);
            nd.add_input(delta);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                nd.set_attr_bool("use_locking", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ApplyProximalGradientDescent' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        var: crate::Output,
        alpha: crate::Output,
        l1: crate::Output,
        l2: crate::Output,
        delta: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ApplyProximalGradientDescentInst> {
        let op = scope.new_operation("ApplyProximalGradientDescent", |builder| {
            builder.add_input(var);
            builder.add_input(alpha);
            builder.add_input(l1);
            builder.add_input(l2);
            builder.add_input(delta);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                builder.set_attr_bool("use_locking", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ApplyProximalGradientDescentInst { op })
    }
}
impl ApplyProximalGradientDescentInst {
    /// Returns the 'out' Output of this 'ApplyProximalGradientDescent' operation.
    pub fn out(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'var' Input of this 'ApplyProximalGradientDescent' operation.
    pub fn var(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'alpha' Input of this 'ApplyProximalGradientDescent' operation.
    pub fn alpha(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'l1' Input of this 'ApplyProximalGradientDescent' operation.
    pub fn l1(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'l2' Input of this 'ApplyProximalGradientDescent' operation.
    pub fn l2(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'delta' Input of this 'ApplyProximalGradientDescent' operation.
    pub fn delta(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
}
impl From<ApplyProximalGradientDescentInst> for crate::Operation {
    fn from(inst: ApplyProximalGradientDescentInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ApplyProximalGradientDescent::new().build(var, alpha, l1, l2, delta, scope)`.
pub fn apply_proximal_gradient_descent<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
>(
    var: O0,
    alpha: O1,
    l1: O2,
    l2: O3,
    delta: O4,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ApplyProximalGradientDescent::new().build(var, alpha, l1, l2, delta, scope)
}

/// Builder for the `ApplyRMSProp` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ApplyRMSProp {
    T: ::std::option::Option<crate::DataType>,
    use_locking: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ApplyRMSProp' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ApplyRMSPropInst {
    /// An instance of a fully built ApplyRMSProp Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ApplyRMSProp {
    /// Creates a new `ApplyRMSProp`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_locking` attribute.
    pub fn use_locking<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.use_locking = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ApplyRMSProp` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
        O6: ::std::convert::Into<crate::Output>,
        O7: ::std::convert::Into<crate::Output>,
    >(
        &self,
        var: O0,
        ms: O1,
        mom: O2,
        lr: O3,
        rho: O4,
        momentum: O5,
        epsilon: O6,
        grad: O7,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            var.into(),
            ms.into(),
            mom.into(),
            lr.into(),
            rho.into(),
            momentum.into(),
            epsilon.into(),
            grad.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        var: crate::Output,
        ms: crate::Output,
        mom: crate::Output,
        lr: crate::Output,
        rho: crate::Output,
        momentum: crate::Output,
        epsilon: crate::Output,
        grad: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ApplyRMSProp", |nd| {
            nd.add_input(var);
            nd.add_input(ms);
            nd.add_input(mom);
            nd.add_input(lr);
            nd.add_input(rho);
            nd.add_input(momentum);
            nd.add_input(epsilon);
            nd.add_input(grad);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                nd.set_attr_bool("use_locking", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ApplyRMSProp' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        var: crate::Output,
        ms: crate::Output,
        mom: crate::Output,
        lr: crate::Output,
        rho: crate::Output,
        momentum: crate::Output,
        epsilon: crate::Output,
        grad: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ApplyRMSPropInst> {
        let op = scope.new_operation("ApplyRMSProp", |builder| {
            builder.add_input(var);
            builder.add_input(ms);
            builder.add_input(mom);
            builder.add_input(lr);
            builder.add_input(rho);
            builder.add_input(momentum);
            builder.add_input(epsilon);
            builder.add_input(grad);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                builder.set_attr_bool("use_locking", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ApplyRMSPropInst { op })
    }
}
impl ApplyRMSPropInst {
    /// Returns the 'out' Output of this 'ApplyRMSProp' operation.
    pub fn out(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'var' Input of this 'ApplyRMSProp' operation.
    pub fn var(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'ms' Input of this 'ApplyRMSProp' operation.
    pub fn ms(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'mom' Input of this 'ApplyRMSProp' operation.
    pub fn mom(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'lr' Input of this 'ApplyRMSProp' operation.
    pub fn lr(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'rho' Input of this 'ApplyRMSProp' operation.
    pub fn rho(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
    /// Returns the 'momentum' Input of this 'ApplyRMSProp' operation.
    pub fn momentum(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 5,
        }
    }
    /// Returns the 'epsilon' Input of this 'ApplyRMSProp' operation.
    pub fn epsilon(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 6,
        }
    }
    /// Returns the 'grad' Input of this 'ApplyRMSProp' operation.
    pub fn grad(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 7,
        }
    }
}
impl From<ApplyRMSPropInst> for crate::Operation {
    fn from(inst: ApplyRMSPropInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ApplyRMSProp::new().build(var, ms, mom, lr, rho, momentum, epsilon, grad, scope)`.
pub fn apply_rmsprop<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
    O6: ::std::convert::Into<crate::Output>,
    O7: ::std::convert::Into<crate::Output>,
>(
    var: O0,
    ms: O1,
    mom: O2,
    lr: O3,
    rho: O4,
    momentum: O5,
    epsilon: O6,
    grad: O7,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ApplyRMSProp::new().build(var, ms, mom, lr, rho, momentum, epsilon, grad, scope)
}

/// Builder for the `ApproxTopK` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ApproxTopK {
    k: ::std::option::Option<i64>,
    reduction_dimension: ::std::option::Option<i64>,
    recall_target: ::std::option::Option<f32>,
    is_max_k: ::std::option::Option<bool>,
    reduction_input_size_override: ::std::option::Option<i64>,
    aggregate_to_topk: ::std::option::Option<bool>,
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ApproxTopK' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ApproxTopKInst {
    /// An instance of a fully built ApproxTopK Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ApproxTopK {
    /// Creates a new `ApproxTopK`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `k` attribute.
    pub fn k<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.k = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `reduction_dimension` attribute.
    pub fn reduction_dimension<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.reduction_dimension = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `recall_target` attribute.
    pub fn recall_target<ArgType: ::std::convert::Into<f32>>(mut self, value: ArgType) -> Self {
        self.recall_target = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `is_max_k` attribute.
    pub fn is_max_k<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.is_max_k = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `reduction_input_size_override` attribute.
    pub fn reduction_input_size_override<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.reduction_input_size_override = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `aggregate_to_topk` attribute.
    pub fn aggregate_to_topk<ArgType: ::std::convert::Into<bool>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.aggregate_to_topk = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ApproxTopK` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ApproxTopK", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.k {
                nd.set_attr_int("k", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.reduction_dimension {
                nd.set_attr_int("reduction_dimension", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.recall_target {
                nd.set_attr_float("recall_target", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.is_max_k {
                nd.set_attr_bool("is_max_k", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.reduction_input_size_override {
                nd.set_attr_int("reduction_input_size_override", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.aggregate_to_topk {
                nd.set_attr_bool("aggregate_to_topk", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ApproxTopK' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ApproxTopKInst> {
        let op = scope.new_operation("ApproxTopK", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.k {
                builder.set_attr_int("k", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.reduction_dimension {
                builder.set_attr_int("reduction_dimension", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.recall_target {
                builder.set_attr_float("recall_target", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.is_max_k {
                builder.set_attr_bool("is_max_k", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.reduction_input_size_override {
                builder.set_attr_int("reduction_input_size_override", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.aggregate_to_topk {
                builder.set_attr_bool("aggregate_to_topk", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ApproxTopKInst { op })
    }
}
impl ApproxTopKInst {
    /// Returns the 'values' Output of this 'ApproxTopK' operation.
    pub fn values(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'indices' Output of this 'ApproxTopK' operation.
    pub fn indices(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'input' Input of this 'ApproxTopK' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<ApproxTopKInst> for crate::Operation {
    fn from(inst: ApproxTopKInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ApproxTopK::new().build(input, scope)`.
pub fn approx_top_k<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ApproxTopK::new().build(input, scope)
}

/// Builder for the `ApproximateEqual` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ApproximateEqual {
    T: ::std::option::Option<crate::DataType>,
    tolerance: ::std::option::Option<f32>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ApproximateEqual' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ApproximateEqualInst {
    /// An instance of a fully built ApproximateEqual Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ApproximateEqual {
    /// Creates a new `ApproximateEqual`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `tolerance` attribute.
    pub fn tolerance<ArgType: ::std::convert::Into<f32>>(mut self, value: ArgType) -> Self {
        self.tolerance = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ApproximateEqual` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        x: O0,
        y: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), y.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        y: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ApproximateEqual", |nd| {
            nd.add_input(x);
            nd.add_input(y);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.tolerance {
                nd.set_attr_float("tolerance", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ApproximateEqual' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        y: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ApproximateEqualInst> {
        let op = scope.new_operation("ApproximateEqual", |builder| {
            builder.add_input(x);
            builder.add_input(y);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.tolerance {
                builder.set_attr_float("tolerance", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ApproximateEqualInst { op })
    }
}
impl ApproximateEqualInst {
    /// Returns the 'z' Output of this 'ApproximateEqual' operation.
    pub fn z(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'ApproximateEqual' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'y' Input of this 'ApproximateEqual' operation.
    pub fn y(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<ApproximateEqualInst> for crate::Operation {
    fn from(inst: ApproximateEqualInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ApproximateEqual::new().build(x, y, scope)`.
pub fn approximate_equal<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    x: O0,
    y: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ApproximateEqual::new().build(x, y, scope)
}

/// Builder for the `ArgMax` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ArgMax {
    T: ::std::option::Option<crate::DataType>,
    Tidx: ::std::option::Option<crate::DataType>,
    output_type: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ArgMax' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ArgMaxInst {
    /// An instance of a fully built ArgMax Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ArgMax {
    /// Creates a new `ArgMax`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tidx` attribute.
    pub fn Tidx<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Tidx = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_type` attribute.
    pub fn output_type<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_type = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ArgMax` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        dimension: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), dimension.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        dimension: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ArgMax", |nd| {
            nd.add_input(input);
            nd.add_input(dimension);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tidx {
                nd.set_attr_type("Tidx", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_type {
                nd.set_attr_type("output_type", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ArgMax' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        dimension: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ArgMaxInst> {
        let op = scope.new_operation("ArgMax", |builder| {
            builder.add_input(input);
            builder.add_input(dimension);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tidx {
                builder.set_attr_type("Tidx", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_type {
                builder.set_attr_type("output_type", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ArgMaxInst { op })
    }
}
impl ArgMaxInst {
    /// Returns the 'output' Output of this 'ArgMax' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'ArgMax' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'dimension' Input of this 'ArgMax' operation.
    pub fn dimension(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<ArgMaxInst> for crate::Operation {
    fn from(inst: ArgMaxInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ArgMax::new().build(input, dimension, scope)`.
pub fn arg_max<O0: ::std::convert::Into<crate::Output>, O1: ::std::convert::Into<crate::Output>>(
    input: O0,
    dimension: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ArgMax::new().build(input, dimension, scope)
}

/// Builder for the `ArgMin` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ArgMin {
    T: ::std::option::Option<crate::DataType>,
    Tidx: ::std::option::Option<crate::DataType>,
    output_type: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ArgMin' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ArgMinInst {
    /// An instance of a fully built ArgMin Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ArgMin {
    /// Creates a new `ArgMin`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tidx` attribute.
    pub fn Tidx<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Tidx = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_type` attribute.
    pub fn output_type<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_type = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ArgMin` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        dimension: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), dimension.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        dimension: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ArgMin", |nd| {
            nd.add_input(input);
            nd.add_input(dimension);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tidx {
                nd.set_attr_type("Tidx", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_type {
                nd.set_attr_type("output_type", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ArgMin' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        dimension: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ArgMinInst> {
        let op = scope.new_operation("ArgMin", |builder| {
            builder.add_input(input);
            builder.add_input(dimension);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tidx {
                builder.set_attr_type("Tidx", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_type {
                builder.set_attr_type("output_type", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ArgMinInst { op })
    }
}
impl ArgMinInst {
    /// Returns the 'output' Output of this 'ArgMin' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'ArgMin' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'dimension' Input of this 'ArgMin' operation.
    pub fn dimension(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<ArgMinInst> for crate::Operation {
    fn from(inst: ArgMinInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ArgMin::new().build(input, dimension, scope)`.
pub fn arg_min<O0: ::std::convert::Into<crate::Output>, O1: ::std::convert::Into<crate::Output>>(
    input: O0,
    dimension: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ArgMin::new().build(input, dimension, scope)
}

/// Builder for the `AsString` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct AsString {
    T: ::std::option::Option<crate::DataType>,
    precision: ::std::option::Option<i64>,
    scientific: ::std::option::Option<bool>,
    shortest: ::std::option::Option<bool>,
    width: ::std::option::Option<i64>,
    fill: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'AsString' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct AsStringInst {
    /// An instance of a fully built AsString Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl AsString {
    /// Creates a new `AsString`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `precision` attribute.
    pub fn precision<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.precision = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `scientific` attribute.
    pub fn scientific<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.scientific = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shortest` attribute.
    pub fn shortest<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.shortest = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `width` attribute.
    pub fn width<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.width = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `fill` attribute.
    pub fn fill<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.fill = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `AsString` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("AsString", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.precision {
                nd.set_attr_int("precision", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.scientific {
                nd.set_attr_bool("scientific", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shortest {
                nd.set_attr_bool("shortest", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.width {
                nd.set_attr_int("width", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.fill {
                nd.set_attr_string("fill", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'AsString' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<AsStringInst> {
        let op = scope.new_operation("AsString", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.precision {
                builder.set_attr_int("precision", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.scientific {
                builder.set_attr_bool("scientific", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shortest {
                builder.set_attr_bool("shortest", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.width {
                builder.set_attr_int("width", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.fill {
                builder.set_attr_string("fill", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(AsStringInst { op })
    }
}
impl AsStringInst {
    /// Returns the 'output' Output of this 'AsString' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'AsString' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<AsStringInst> for crate::Operation {
    fn from(inst: AsStringInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `AsString::new().build(input, scope)`.
pub fn as_string<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    AsString::new().build(input, scope)
}

/// Builder for the `Asin` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Asin {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Asin' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct AsinInst {
    /// An instance of a fully built Asin Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Asin {
    /// Creates a new `Asin`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Asin` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        x: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Asin", |nd| {
            nd.add_input(x);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Asin' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<AsinInst> {
        let op = scope.new_operation("Asin", |builder| {
            builder.add_input(x);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(AsinInst { op })
    }
}
impl AsinInst {
    /// Returns the 'y' Output of this 'Asin' operation.
    pub fn y(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'Asin' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<AsinInst> for crate::Operation {
    fn from(inst: AsinInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Asin::new().build(x, scope)`.
pub fn asin<O0: ::std::convert::Into<crate::Output>>(
    x: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Asin::new().build(x, scope)
}

/// Builder for the `Asinh` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Asinh {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Asinh' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct AsinhInst {
    /// An instance of a fully built Asinh Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Asinh {
    /// Creates a new `Asinh`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Asinh` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        x: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Asinh", |nd| {
            nd.add_input(x);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Asinh' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<AsinhInst> {
        let op = scope.new_operation("Asinh", |builder| {
            builder.add_input(x);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(AsinhInst { op })
    }
}
impl AsinhInst {
    /// Returns the 'y' Output of this 'Asinh' operation.
    pub fn y(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'Asinh' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<AsinhInst> for crate::Operation {
    fn from(inst: AsinhInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Asinh::new().build(x, scope)`.
pub fn asinh<O0: ::std::convert::Into<crate::Output>>(
    x: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Asinh::new().build(x, scope)
}

/// Builder for the `Assert` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Assert {
    T: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    summarize: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Assert' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct AssertInst {
    /// An instance of a fully built Assert Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Assert {
    /// Creates a new `Assert`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `summarize` attribute.
    pub fn summarize<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.summarize = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Assert` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        condition: O0,
        data: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(condition.into(), data.into(), scope)
    }
    fn build_impl(
        &self,
        condition: crate::Output,
        data: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Assert", |nd| {
            nd.add_input(condition);
            nd.add_input(data);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type_list("T", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.summarize {
                nd.set_attr_int("summarize", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Assert' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        condition: crate::Output,
        data: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<AssertInst> {
        let op = scope.new_operation("Assert", |builder| {
            builder.add_input(condition);
            builder.add_input(data);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type_list("T", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.summarize {
                builder.set_attr_int("summarize", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(AssertInst { op })
    }
}
impl AssertInst {
    /// Returns the 'condition' Input of this 'Assert' operation.
    pub fn condition(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'data' Input of this 'Assert' operation.
    pub fn data(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<AssertInst> for crate::Operation {
    fn from(inst: AssertInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Assert::new().build(condition, data, scope)`.
pub fn assert<O0: ::std::convert::Into<crate::Output>, O1: ::std::convert::Into<crate::Output>>(
    condition: O0,
    data: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Assert::new().build(condition, data, scope)
}

/// Builder for the `AssertCardinalityDataset` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct AssertCardinalityDataset {
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'AssertCardinalityDataset' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct AssertCardinalityDatasetInst {
    /// An instance of a fully built AssertCardinalityDataset Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl AssertCardinalityDataset {
    /// Creates a new `AssertCardinalityDataset`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `AssertCardinalityDataset` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input_dataset: O0,
        cardinality: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input_dataset.into(), cardinality.into(), scope)
    }
    fn build_impl(
        &self,
        input_dataset: crate::Output,
        cardinality: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("AssertCardinalityDataset", |nd| {
            nd.add_input(input_dataset);
            nd.add_input(cardinality);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'AssertCardinalityDataset' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_dataset: crate::Output,
        cardinality: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<AssertCardinalityDatasetInst> {
        let op = scope.new_operation("AssertCardinalityDataset", |builder| {
            builder.add_input(input_dataset);
            builder.add_input(cardinality);
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(AssertCardinalityDatasetInst { op })
    }
}
impl AssertCardinalityDatasetInst {
    /// Returns the 'handle' Output of this 'AssertCardinalityDataset' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_dataset' Input of this 'AssertCardinalityDataset' operation.
    pub fn input_dataset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'cardinality' Input of this 'AssertCardinalityDataset' operation.
    pub fn cardinality(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<AssertCardinalityDatasetInst> for crate::Operation {
    fn from(inst: AssertCardinalityDatasetInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `AssertCardinalityDataset::new().build(input_dataset, cardinality, scope)`.
pub fn assert_cardinality_dataset<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    input_dataset: O0,
    cardinality: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    AssertCardinalityDataset::new().build(input_dataset, cardinality, scope)
}

/// Builder for the `AssertNextDataset` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct AssertNextDataset {
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'AssertNextDataset' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct AssertNextDatasetInst {
    /// An instance of a fully built AssertNextDataset Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl AssertNextDataset {
    /// Creates a new `AssertNextDataset`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `AssertNextDataset` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input_dataset: O0,
        transformations: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input_dataset.into(), transformations.into(), scope)
    }
    fn build_impl(
        &self,
        input_dataset: crate::Output,
        transformations: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("AssertNextDataset", |nd| {
            nd.add_input(input_dataset);
            nd.add_input(transformations);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'AssertNextDataset' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_dataset: crate::Output,
        transformations: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<AssertNextDatasetInst> {
        let op = scope.new_operation("AssertNextDataset", |builder| {
            builder.add_input(input_dataset);
            builder.add_input(transformations);
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(AssertNextDatasetInst { op })
    }
}
impl AssertNextDatasetInst {
    /// Returns the 'handle' Output of this 'AssertNextDataset' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_dataset' Input of this 'AssertNextDataset' operation.
    pub fn input_dataset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'transformations' Input of this 'AssertNextDataset' operation.
    pub fn transformations(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<AssertNextDatasetInst> for crate::Operation {
    fn from(inst: AssertNextDatasetInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `AssertNextDataset::new().build(input_dataset, transformations, scope)`.
pub fn assert_next_dataset<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    input_dataset: O0,
    transformations: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    AssertNextDataset::new().build(input_dataset, transformations, scope)
}

/// Builder for the `AssertPrevDataset` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct AssertPrevDataset {
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'AssertPrevDataset' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct AssertPrevDatasetInst {
    /// An instance of a fully built AssertPrevDataset Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl AssertPrevDataset {
    /// Creates a new `AssertPrevDataset`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `AssertPrevDataset` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input_dataset: O0,
        transformations: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input_dataset.into(), transformations.into(), scope)
    }
    fn build_impl(
        &self,
        input_dataset: crate::Output,
        transformations: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("AssertPrevDataset", |nd| {
            nd.add_input(input_dataset);
            nd.add_input(transformations);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'AssertPrevDataset' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_dataset: crate::Output,
        transformations: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<AssertPrevDatasetInst> {
        let op = scope.new_operation("AssertPrevDataset", |builder| {
            builder.add_input(input_dataset);
            builder.add_input(transformations);
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(AssertPrevDatasetInst { op })
    }
}
impl AssertPrevDatasetInst {
    /// Returns the 'handle' Output of this 'AssertPrevDataset' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_dataset' Input of this 'AssertPrevDataset' operation.
    pub fn input_dataset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'transformations' Input of this 'AssertPrevDataset' operation.
    pub fn transformations(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<AssertPrevDatasetInst> for crate::Operation {
    fn from(inst: AssertPrevDatasetInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `AssertPrevDataset::new().build(input_dataset, transformations, scope)`.
pub fn assert_prev_dataset<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    input_dataset: O0,
    transformations: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    AssertPrevDataset::new().build(input_dataset, transformations, scope)
}

/// Builder for the `Assign` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Assign {
    T: ::std::option::Option<crate::DataType>,
    validate_shape: ::std::option::Option<bool>,
    use_locking: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Assign' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct AssignInst {
    /// An instance of a fully built Assign Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Assign {
    /// Creates a new `Assign`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `validate_shape` attribute.
    pub fn validate_shape<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.validate_shape = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_locking` attribute.
    pub fn use_locking<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.use_locking = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Assign` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        ref_: O0,
        value: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(ref_.into(), value.into(), scope)
    }
    fn build_impl(
        &self,
        ref_: crate::Output,
        value: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Assign", |nd| {
            nd.add_input(ref_);
            nd.add_input(value);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.validate_shape {
                nd.set_attr_bool("validate_shape", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                nd.set_attr_bool("use_locking", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Assign' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        ref_: crate::Output,
        value: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<AssignInst> {
        let op = scope.new_operation("Assign", |builder| {
            builder.add_input(ref_);
            builder.add_input(value);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.validate_shape {
                builder.set_attr_bool("validate_shape", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                builder.set_attr_bool("use_locking", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(AssignInst { op })
    }
}
impl AssignInst {
    /// Returns the 'output_ref' Output of this 'Assign' operation.
    pub fn output_ref(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'ref_' Input of this 'Assign' operation.
    pub fn ref_(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'value' Input of this 'Assign' operation.
    pub fn value(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<AssignInst> for crate::Operation {
    fn from(inst: AssignInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Assign::new().build(ref_, value, scope)`.
pub fn assign<O0: ::std::convert::Into<crate::Output>, O1: ::std::convert::Into<crate::Output>>(
    ref_: O0,
    value: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Assign::new().build(ref_, value, scope)
}

/// Builder for the `AssignAdd` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct AssignAdd {
    T: ::std::option::Option<crate::DataType>,
    use_locking: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'AssignAdd' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct AssignAddInst {
    /// An instance of a fully built AssignAdd Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl AssignAdd {
    /// Creates a new `AssignAdd`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_locking` attribute.
    pub fn use_locking<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.use_locking = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `AssignAdd` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        ref_: O0,
        value: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(ref_.into(), value.into(), scope)
    }
    fn build_impl(
        &self,
        ref_: crate::Output,
        value: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("AssignAdd", |nd| {
            nd.add_input(ref_);
            nd.add_input(value);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                nd.set_attr_bool("use_locking", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'AssignAdd' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        ref_: crate::Output,
        value: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<AssignAddInst> {
        let op = scope.new_operation("AssignAdd", |builder| {
            builder.add_input(ref_);
            builder.add_input(value);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                builder.set_attr_bool("use_locking", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(AssignAddInst { op })
    }
}
impl AssignAddInst {
    /// Returns the 'output_ref' Output of this 'AssignAdd' operation.
    pub fn output_ref(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'ref_' Input of this 'AssignAdd' operation.
    pub fn ref_(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'value' Input of this 'AssignAdd' operation.
    pub fn value(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<AssignAddInst> for crate::Operation {
    fn from(inst: AssignAddInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `AssignAdd::new().build(ref_, value, scope)`.
pub fn assign_add<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    ref_: O0,
    value: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    AssignAdd::new().build(ref_, value, scope)
}

/// Builder for the `AssignAddVariableOp` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct AssignAddVariableOp {
    dtype: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'AssignAddVariableOp' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct AssignAddVariableOpInst {
    /// An instance of a fully built AssignAddVariableOp Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl AssignAddVariableOp {
    /// Creates a new `AssignAddVariableOp`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `dtype` attribute.
    pub fn dtype<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `AssignAddVariableOp` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        resource: O0,
        value: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(resource.into(), value.into(), scope)
    }
    fn build_impl(
        &self,
        resource: crate::Output,
        value: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("AssignAddVariableOp", |nd| {
            nd.add_input(resource);
            nd.add_input(value);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                nd.set_attr_type("dtype", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'AssignAddVariableOp' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        resource: crate::Output,
        value: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<AssignAddVariableOpInst> {
        let op = scope.new_operation("AssignAddVariableOp", |builder| {
            builder.add_input(resource);
            builder.add_input(value);
            if let ::std::option::Option::Some(value) = &self.dtype {
                builder.set_attr_type("dtype", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(AssignAddVariableOpInst { op })
    }
}
impl AssignAddVariableOpInst {
    /// Returns the 'resource' Input of this 'AssignAddVariableOp' operation.
    pub fn resource(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'value' Input of this 'AssignAddVariableOp' operation.
    pub fn value(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<AssignAddVariableOpInst> for crate::Operation {
    fn from(inst: AssignAddVariableOpInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `AssignAddVariableOp::new().build(resource, value, scope)`.
pub fn assign_add_variable_op<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    resource: O0,
    value: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    AssignAddVariableOp::new().build(resource, value, scope)
}

/// Builder for the `AssignSub` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct AssignSub {
    T: ::std::option::Option<crate::DataType>,
    use_locking: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'AssignSub' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct AssignSubInst {
    /// An instance of a fully built AssignSub Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl AssignSub {
    /// Creates a new `AssignSub`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_locking` attribute.
    pub fn use_locking<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.use_locking = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `AssignSub` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        ref_: O0,
        value: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(ref_.into(), value.into(), scope)
    }
    fn build_impl(
        &self,
        ref_: crate::Output,
        value: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("AssignSub", |nd| {
            nd.add_input(ref_);
            nd.add_input(value);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                nd.set_attr_bool("use_locking", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'AssignSub' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        ref_: crate::Output,
        value: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<AssignSubInst> {
        let op = scope.new_operation("AssignSub", |builder| {
            builder.add_input(ref_);
            builder.add_input(value);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                builder.set_attr_bool("use_locking", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(AssignSubInst { op })
    }
}
impl AssignSubInst {
    /// Returns the 'output_ref' Output of this 'AssignSub' operation.
    pub fn output_ref(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'ref_' Input of this 'AssignSub' operation.
    pub fn ref_(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'value' Input of this 'AssignSub' operation.
    pub fn value(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<AssignSubInst> for crate::Operation {
    fn from(inst: AssignSubInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `AssignSub::new().build(ref_, value, scope)`.
pub fn assign_sub<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    ref_: O0,
    value: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    AssignSub::new().build(ref_, value, scope)
}

/// Builder for the `AssignSubVariableOp` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct AssignSubVariableOp {
    dtype: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'AssignSubVariableOp' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct AssignSubVariableOpInst {
    /// An instance of a fully built AssignSubVariableOp Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl AssignSubVariableOp {
    /// Creates a new `AssignSubVariableOp`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `dtype` attribute.
    pub fn dtype<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `AssignSubVariableOp` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        resource: O0,
        value: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(resource.into(), value.into(), scope)
    }
    fn build_impl(
        &self,
        resource: crate::Output,
        value: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("AssignSubVariableOp", |nd| {
            nd.add_input(resource);
            nd.add_input(value);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                nd.set_attr_type("dtype", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'AssignSubVariableOp' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        resource: crate::Output,
        value: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<AssignSubVariableOpInst> {
        let op = scope.new_operation("AssignSubVariableOp", |builder| {
            builder.add_input(resource);
            builder.add_input(value);
            if let ::std::option::Option::Some(value) = &self.dtype {
                builder.set_attr_type("dtype", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(AssignSubVariableOpInst { op })
    }
}
impl AssignSubVariableOpInst {
    /// Returns the 'resource' Input of this 'AssignSubVariableOp' operation.
    pub fn resource(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'value' Input of this 'AssignSubVariableOp' operation.
    pub fn value(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<AssignSubVariableOpInst> for crate::Operation {
    fn from(inst: AssignSubVariableOpInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `AssignSubVariableOp::new().build(resource, value, scope)`.
pub fn assign_sub_variable_op<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    resource: O0,
    value: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    AssignSubVariableOp::new().build(resource, value, scope)
}

/// Builder for the `AssignVariableOp` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct AssignVariableOp {
    dtype: ::std::option::Option<crate::DataType>,
    validate_shape: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'AssignVariableOp' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct AssignVariableOpInst {
    /// An instance of a fully built AssignVariableOp Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl AssignVariableOp {
    /// Creates a new `AssignVariableOp`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `dtype` attribute.
    pub fn dtype<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `validate_shape` attribute.
    pub fn validate_shape<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.validate_shape = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `AssignVariableOp` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        resource: O0,
        value: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(resource.into(), value.into(), scope)
    }
    fn build_impl(
        &self,
        resource: crate::Output,
        value: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("AssignVariableOp", |nd| {
            nd.add_input(resource);
            nd.add_input(value);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                nd.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.validate_shape {
                nd.set_attr_bool("validate_shape", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'AssignVariableOp' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        resource: crate::Output,
        value: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<AssignVariableOpInst> {
        let op = scope.new_operation("AssignVariableOp", |builder| {
            builder.add_input(resource);
            builder.add_input(value);
            if let ::std::option::Option::Some(value) = &self.dtype {
                builder.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.validate_shape {
                builder.set_attr_bool("validate_shape", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(AssignVariableOpInst { op })
    }
}
impl AssignVariableOpInst {
    /// Returns the 'resource' Input of this 'AssignVariableOp' operation.
    pub fn resource(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'value' Input of this 'AssignVariableOp' operation.
    pub fn value(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<AssignVariableOpInst> for crate::Operation {
    fn from(inst: AssignVariableOpInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `AssignVariableOp::new().build(resource, value, scope)`.
pub fn assign_variable_op<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    resource: O0,
    value: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    AssignVariableOp::new().build(resource, value, scope)
}

/// Builder for the `AssignVariableXlaConcatND` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct AssignVariableXlaConcatND {
    T: ::std::option::Option<crate::DataType>,
    N: ::std::option::Option<i64>,
    num_concats: ::std::option::Option<::std::vec::Vec<i64>>,
    paddings: ::std::option::Option<::std::vec::Vec<i64>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'AssignVariableXlaConcatND' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct AssignVariableXlaConcatNDInst {
    /// An instance of a fully built AssignVariableXlaConcatND Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl AssignVariableXlaConcatND {
    /// Creates a new `AssignVariableXlaConcatND`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `N` attribute.
    pub fn N<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.N = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `num_concats` attribute.
    pub fn num_concats<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.num_concats = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `paddings` attribute.
    pub fn paddings<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.paddings = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `AssignVariableXlaConcatND` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        resource: O0,
        inputs: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(resource.into(), inputs.into(), scope)
    }
    fn build_impl(
        &self,
        resource: crate::Output,
        inputs: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("AssignVariableXlaConcatND", |nd| {
            nd.add_input(resource);
            nd.add_input(inputs);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.N {
                nd.set_attr_int("N", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_concats {
                nd.set_attr_int_list("num_concats", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.paddings {
                nd.set_attr_int_list("paddings", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'AssignVariableXlaConcatND' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        resource: crate::Output,
        inputs: Vec<crate::Output>,
        scope: &mut crate::Scope,
    ) -> crate::Result<AssignVariableXlaConcatNDInst> {
        let op = scope.new_operation("AssignVariableXlaConcatND", |builder| {
            builder.add_input(resource);
            builder.add_input_list(&inputs);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            builder.set_attr_int("N", inputs.clone().len() as i64)?;
            if let ::std::option::Option::Some(value) = &self.num_concats {
                builder.set_attr_int_list("num_concats", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.paddings {
                builder.set_attr_int_list("paddings", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(AssignVariableXlaConcatNDInst { op })
    }
}
impl AssignVariableXlaConcatNDInst {
    /// Returns the 'resource' Input of this 'AssignVariableXlaConcatND' operation.
    pub fn resource(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns a Vector of inputs for 'inputs' Input of this AssignVariableXlaConcatND operation.
    pub fn inputs(&self) -> crate::Result<Vec<crate::Input>> {
        let mut Inputs = vec![];
        for i in 1..self.op.get_attr_int("N")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
}
impl From<AssignVariableXlaConcatNDInst> for crate::Operation {
    fn from(inst: AssignVariableXlaConcatNDInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `AssignVariableXlaConcatND::new().build(resource, inputs, scope)`.
pub fn assign_variable_xla_concat_nd<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    resource: O0,
    inputs: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    AssignVariableXlaConcatND::new().build(resource, inputs, scope)
}

/// Builder for the `Atan` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Atan {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Atan' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct AtanInst {
    /// An instance of a fully built Atan Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Atan {
    /// Creates a new `Atan`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Atan` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        x: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Atan", |nd| {
            nd.add_input(x);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Atan' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<AtanInst> {
        let op = scope.new_operation("Atan", |builder| {
            builder.add_input(x);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(AtanInst { op })
    }
}
impl AtanInst {
    /// Returns the 'y' Output of this 'Atan' operation.
    pub fn y(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'Atan' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<AtanInst> for crate::Operation {
    fn from(inst: AtanInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Atan::new().build(x, scope)`.
pub fn atan<O0: ::std::convert::Into<crate::Output>>(
    x: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Atan::new().build(x, scope)
}

/// Builder for the `Atan2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Atan2 {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Atan2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct Atan2Inst {
    /// An instance of a fully built Atan2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Atan2 {
    /// Creates a new `Atan2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Atan2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        y: O0,
        x: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(y.into(), x.into(), scope)
    }
    fn build_impl(
        &self,
        y: crate::Output,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Atan2", |nd| {
            nd.add_input(y);
            nd.add_input(x);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Atan2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        y: crate::Output,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<Atan2Inst> {
        let op = scope.new_operation("Atan2", |builder| {
            builder.add_input(y);
            builder.add_input(x);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(Atan2Inst { op })
    }
}
impl Atan2Inst {
    /// Returns the 'z' Output of this 'Atan2' operation.
    pub fn z(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'y' Input of this 'Atan2' operation.
    pub fn y(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'Atan2' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<Atan2Inst> for crate::Operation {
    fn from(inst: Atan2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Atan2::new().build(y, x, scope)`.
pub fn atan2<O0: ::std::convert::Into<crate::Output>, O1: ::std::convert::Into<crate::Output>>(
    y: O0,
    x: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Atan2::new().build(y, x, scope)
}

/// Builder for the `Atanh` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Atanh {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Atanh' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct AtanhInst {
    /// An instance of a fully built Atanh Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Atanh {
    /// Creates a new `Atanh`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Atanh` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        x: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Atanh", |nd| {
            nd.add_input(x);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Atanh' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<AtanhInst> {
        let op = scope.new_operation("Atanh", |builder| {
            builder.add_input(x);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(AtanhInst { op })
    }
}
impl AtanhInst {
    /// Returns the 'y' Output of this 'Atanh' operation.
    pub fn y(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'Atanh' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<AtanhInst> for crate::Operation {
    fn from(inst: AtanhInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Atanh::new().build(x, scope)`.
pub fn atanh<O0: ::std::convert::Into<crate::Output>>(
    x: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Atanh::new().build(x, scope)
}

/// Builder for the `AudioSpectrogram` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct AudioSpectrogram {
    window_size: ::std::option::Option<i64>,
    stride: ::std::option::Option<i64>,
    magnitude_squared: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'AudioSpectrogram' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct AudioSpectrogramInst {
    /// An instance of a fully built AudioSpectrogram Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl AudioSpectrogram {
    /// Creates a new `AudioSpectrogram`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `window_size` attribute.
    pub fn window_size<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.window_size = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `stride` attribute.
    pub fn stride<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.stride = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `magnitude_squared` attribute.
    pub fn magnitude_squared<ArgType: ::std::convert::Into<bool>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.magnitude_squared = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `AudioSpectrogram` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("AudioSpectrogram", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.window_size {
                nd.set_attr_int("window_size", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.stride {
                nd.set_attr_int("stride", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.magnitude_squared {
                nd.set_attr_bool("magnitude_squared", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'AudioSpectrogram' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<AudioSpectrogramInst> {
        let op = scope.new_operation("AudioSpectrogram", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.window_size {
                builder.set_attr_int("window_size", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.stride {
                builder.set_attr_int("stride", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.magnitude_squared {
                builder.set_attr_bool("magnitude_squared", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(AudioSpectrogramInst { op })
    }
}
impl AudioSpectrogramInst {
    /// Returns the 'spectrogram' Output of this 'AudioSpectrogram' operation.
    pub fn spectrogram(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'AudioSpectrogram' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<AudioSpectrogramInst> for crate::Operation {
    fn from(inst: AudioSpectrogramInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `AudioSpectrogram::new().build(input, scope)`.
pub fn audio_spectrogram<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    AudioSpectrogram::new().build(input, scope)
}

/// Builder for the `AudioSummary` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct AudioSummary {
    sample_rate: ::std::option::Option<f32>,
    max_outputs: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'AudioSummary' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct AudioSummaryInst {
    /// An instance of a fully built AudioSummary Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl AudioSummary {
    /// Creates a new `AudioSummary`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `sample_rate` attribute.
    pub fn sample_rate<ArgType: ::std::convert::Into<f32>>(mut self, value: ArgType) -> Self {
        self.sample_rate = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `max_outputs` attribute.
    pub fn max_outputs<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.max_outputs = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `AudioSummary` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        tag: O0,
        tensor: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(tag.into(), tensor.into(), scope)
    }
    fn build_impl(
        &self,
        tag: crate::Output,
        tensor: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("AudioSummary", |nd| {
            nd.add_input(tag);
            nd.add_input(tensor);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.sample_rate {
                nd.set_attr_float("sample_rate", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.max_outputs {
                nd.set_attr_int("max_outputs", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'AudioSummary' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        tag: crate::Output,
        tensor: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<AudioSummaryInst> {
        let op = scope.new_operation("AudioSummary", |builder| {
            builder.add_input(tag);
            builder.add_input(tensor);
            if let ::std::option::Option::Some(value) = &self.sample_rate {
                builder.set_attr_float("sample_rate", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.max_outputs {
                builder.set_attr_int("max_outputs", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(AudioSummaryInst { op })
    }
}
impl AudioSummaryInst {
    /// Returns the 'summary' Output of this 'AudioSummary' operation.
    pub fn summary(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'tag' Input of this 'AudioSummary' operation.
    pub fn tag(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'tensor' Input of this 'AudioSummary' operation.
    pub fn tensor(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<AudioSummaryInst> for crate::Operation {
    fn from(inst: AudioSummaryInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `AudioSummary::new().build(tag, tensor, scope)`.
pub fn audio_summary<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    tag: O0,
    tensor: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    AudioSummary::new().build(tag, tensor, scope)
}

/// Builder for the `AudioSummaryV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct AudioSummaryV2 {
    max_outputs: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'AudioSummaryV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct AudioSummaryV2Inst {
    /// An instance of a fully built AudioSummaryV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl AudioSummaryV2 {
    /// Creates a new `AudioSummaryV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `max_outputs` attribute.
    pub fn max_outputs<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.max_outputs = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `AudioSummaryV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        tag: O0,
        tensor: O1,
        sample_rate: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(tag.into(), tensor.into(), sample_rate.into(), scope)
    }
    fn build_impl(
        &self,
        tag: crate::Output,
        tensor: crate::Output,
        sample_rate: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("AudioSummaryV2", |nd| {
            nd.add_input(tag);
            nd.add_input(tensor);
            nd.add_input(sample_rate);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.max_outputs {
                nd.set_attr_int("max_outputs", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'AudioSummaryV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        tag: crate::Output,
        tensor: crate::Output,
        sample_rate: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<AudioSummaryV2Inst> {
        let op = scope.new_operation("AudioSummaryV2", |builder| {
            builder.add_input(tag);
            builder.add_input(tensor);
            builder.add_input(sample_rate);
            if let ::std::option::Option::Some(value) = &self.max_outputs {
                builder.set_attr_int("max_outputs", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(AudioSummaryV2Inst { op })
    }
}
impl AudioSummaryV2Inst {
    /// Returns the 'summary' Output of this 'AudioSummaryV2' operation.
    pub fn summary(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'tag' Input of this 'AudioSummaryV2' operation.
    pub fn tag(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'tensor' Input of this 'AudioSummaryV2' operation.
    pub fn tensor(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'sample_rate' Input of this 'AudioSummaryV2' operation.
    pub fn sample_rate(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<AudioSummaryV2Inst> for crate::Operation {
    fn from(inst: AudioSummaryV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `AudioSummaryV2::new().build(tag, tensor, sample_rate, scope)`.
pub fn audio_summary_v2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    tag: O0,
    tensor: O1,
    sample_rate: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    AudioSummaryV2::new().build(tag, tensor, sample_rate, scope)
}

/// Builder for the `AutoShardDataset` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct AutoShardDataset {
    auto_shard_policy: ::std::option::Option<i64>,
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    num_replicas: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'AutoShardDataset' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct AutoShardDatasetInst {
    /// An instance of a fully built AutoShardDataset Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl AutoShardDataset {
    /// Creates a new `AutoShardDataset`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `auto_shard_policy` attribute.
    pub fn auto_shard_policy<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.auto_shard_policy = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `num_replicas` attribute.
    pub fn num_replicas<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.num_replicas = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `AutoShardDataset` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input_dataset: O0,
        num_workers: O1,
        index: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            input_dataset.into(),
            num_workers.into(),
            index.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        input_dataset: crate::Output,
        num_workers: crate::Output,
        index: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("AutoShardDataset", |nd| {
            nd.add_input(input_dataset);
            nd.add_input(num_workers);
            nd.add_input(index);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.auto_shard_policy {
                nd.set_attr_int("auto_shard_policy", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_replicas {
                nd.set_attr_int("num_replicas", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'AutoShardDataset' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_dataset: crate::Output,
        num_workers: crate::Output,
        index: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<AutoShardDatasetInst> {
        let op = scope.new_operation("AutoShardDataset", |builder| {
            builder.add_input(input_dataset);
            builder.add_input(num_workers);
            builder.add_input(index);
            if let ::std::option::Option::Some(value) = &self.auto_shard_policy {
                builder.set_attr_int("auto_shard_policy", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_replicas {
                builder.set_attr_int("num_replicas", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(AutoShardDatasetInst { op })
    }
}
impl AutoShardDatasetInst {
    /// Returns the 'handle' Output of this 'AutoShardDataset' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_dataset' Input of this 'AutoShardDataset' operation.
    pub fn input_dataset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'num_workers' Input of this 'AutoShardDataset' operation.
    pub fn num_workers(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'index' Input of this 'AutoShardDataset' operation.
    pub fn index(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<AutoShardDatasetInst> for crate::Operation {
    fn from(inst: AutoShardDatasetInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `AutoShardDataset::new().build(input_dataset, num_workers, index, scope)`.
pub fn auto_shard_dataset<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    input_dataset: O0,
    num_workers: O1,
    index: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    AutoShardDataset::new().build(input_dataset, num_workers, index, scope)
}

/// Builder for the `AvgPool` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct AvgPool {
    ksize: ::std::option::Option<::std::vec::Vec<i64>>,
    strides: ::std::option::Option<::std::vec::Vec<i64>>,
    padding: ::std::option::Option<::std::string::String>,
    data_format: ::std::option::Option<::std::string::String>,
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'AvgPool' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct AvgPoolInst {
    /// An instance of a fully built AvgPool Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl AvgPool {
    /// Creates a new `AvgPool`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `ksize` attribute.
    pub fn ksize<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.ksize = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `strides` attribute.
    pub fn strides<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.strides = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `padding` attribute.
    pub fn padding<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.padding = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `data_format` attribute.
    pub fn data_format<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.data_format = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `AvgPool` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        value: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(value.into(), scope)
    }
    fn build_impl(
        &self,
        value: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("AvgPool", |nd| {
            nd.add_input(value);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.ksize {
                nd.set_attr_int_list("ksize", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.strides {
                nd.set_attr_int_list("strides", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding {
                nd.set_attr_string("padding", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.data_format {
                nd.set_attr_string("data_format", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'AvgPool' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        value: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<AvgPoolInst> {
        let op = scope.new_operation("AvgPool", |builder| {
            builder.add_input(value);
            if let ::std::option::Option::Some(value) = &self.ksize {
                builder.set_attr_int_list("ksize", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.strides {
                builder.set_attr_int_list("strides", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding {
                builder.set_attr_string("padding", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.data_format {
                builder.set_attr_string("data_format", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(AvgPoolInst { op })
    }
}
impl AvgPoolInst {
    /// Returns the 'output' Output of this 'AvgPool' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'value' Input of this 'AvgPool' operation.
    pub fn value(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<AvgPoolInst> for crate::Operation {
    fn from(inst: AvgPoolInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `AvgPool::new().build(value, scope)`.
pub fn avg_pool<O0: ::std::convert::Into<crate::Output>>(
    value: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    AvgPool::new().build(value, scope)
}

/// Builder for the `AvgPool3D` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct AvgPool3D {
    ksize: ::std::option::Option<::std::vec::Vec<i64>>,
    strides: ::std::option::Option<::std::vec::Vec<i64>>,
    padding: ::std::option::Option<::std::string::String>,
    data_format: ::std::option::Option<::std::string::String>,
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'AvgPool3D' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct AvgPool3DInst {
    /// An instance of a fully built AvgPool3D Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl AvgPool3D {
    /// Creates a new `AvgPool3D`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `ksize` attribute.
    pub fn ksize<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.ksize = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `strides` attribute.
    pub fn strides<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.strides = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `padding` attribute.
    pub fn padding<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.padding = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `data_format` attribute.
    pub fn data_format<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.data_format = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `AvgPool3D` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("AvgPool3D", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.ksize {
                nd.set_attr_int_list("ksize", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.strides {
                nd.set_attr_int_list("strides", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding {
                nd.set_attr_string("padding", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.data_format {
                nd.set_attr_string("data_format", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'AvgPool3D' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<AvgPool3DInst> {
        let op = scope.new_operation("AvgPool3D", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.ksize {
                builder.set_attr_int_list("ksize", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.strides {
                builder.set_attr_int_list("strides", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding {
                builder.set_attr_string("padding", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.data_format {
                builder.set_attr_string("data_format", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(AvgPool3DInst { op })
    }
}
impl AvgPool3DInst {
    /// Returns the 'output' Output of this 'AvgPool3D' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'AvgPool3D' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<AvgPool3DInst> for crate::Operation {
    fn from(inst: AvgPool3DInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `AvgPool3D::new().build(input, scope)`.
pub fn avg_pool3_d<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    AvgPool3D::new().build(input, scope)
}

/// Builder for the `AvgPool3DGrad` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct AvgPool3DGrad {
    ksize: ::std::option::Option<::std::vec::Vec<i64>>,
    strides: ::std::option::Option<::std::vec::Vec<i64>>,
    padding: ::std::option::Option<::std::string::String>,
    data_format: ::std::option::Option<::std::string::String>,
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'AvgPool3DGrad' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct AvgPool3DGradInst {
    /// An instance of a fully built AvgPool3DGrad Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl AvgPool3DGrad {
    /// Creates a new `AvgPool3DGrad`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `ksize` attribute.
    pub fn ksize<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.ksize = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `strides` attribute.
    pub fn strides<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.strides = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `padding` attribute.
    pub fn padding<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.padding = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `data_format` attribute.
    pub fn data_format<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.data_format = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `AvgPool3DGrad` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        orig_input_shape: O0,
        grad: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(orig_input_shape.into(), grad.into(), scope)
    }
    fn build_impl(
        &self,
        orig_input_shape: crate::Output,
        grad: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("AvgPool3DGrad", |nd| {
            nd.add_input(orig_input_shape);
            nd.add_input(grad);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.ksize {
                nd.set_attr_int_list("ksize", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.strides {
                nd.set_attr_int_list("strides", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding {
                nd.set_attr_string("padding", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.data_format {
                nd.set_attr_string("data_format", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'AvgPool3DGrad' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        orig_input_shape: crate::Output,
        grad: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<AvgPool3DGradInst> {
        let op = scope.new_operation("AvgPool3DGrad", |builder| {
            builder.add_input(orig_input_shape);
            builder.add_input(grad);
            if let ::std::option::Option::Some(value) = &self.ksize {
                builder.set_attr_int_list("ksize", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.strides {
                builder.set_attr_int_list("strides", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding {
                builder.set_attr_string("padding", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.data_format {
                builder.set_attr_string("data_format", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(AvgPool3DGradInst { op })
    }
}
impl AvgPool3DGradInst {
    /// Returns the 'output' Output of this 'AvgPool3DGrad' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'orig_input_shape' Input of this 'AvgPool3DGrad' operation.
    pub fn orig_input_shape(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'grad' Input of this 'AvgPool3DGrad' operation.
    pub fn grad(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<AvgPool3DGradInst> for crate::Operation {
    fn from(inst: AvgPool3DGradInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `AvgPool3DGrad::new().build(orig_input_shape, grad, scope)`.
pub fn avg_pool3_dgrad<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    orig_input_shape: O0,
    grad: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    AvgPool3DGrad::new().build(orig_input_shape, grad, scope)
}

/// Builder for the `AvgPoolGrad` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct AvgPoolGrad {
    ksize: ::std::option::Option<::std::vec::Vec<i64>>,
    strides: ::std::option::Option<::std::vec::Vec<i64>>,
    padding: ::std::option::Option<::std::string::String>,
    data_format: ::std::option::Option<::std::string::String>,
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'AvgPoolGrad' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct AvgPoolGradInst {
    /// An instance of a fully built AvgPoolGrad Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl AvgPoolGrad {
    /// Creates a new `AvgPoolGrad`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `ksize` attribute.
    pub fn ksize<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.ksize = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `strides` attribute.
    pub fn strides<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.strides = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `padding` attribute.
    pub fn padding<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.padding = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `data_format` attribute.
    pub fn data_format<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.data_format = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `AvgPoolGrad` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        orig_input_shape: O0,
        grad: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(orig_input_shape.into(), grad.into(), scope)
    }
    fn build_impl(
        &self,
        orig_input_shape: crate::Output,
        grad: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("AvgPoolGrad", |nd| {
            nd.add_input(orig_input_shape);
            nd.add_input(grad);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.ksize {
                nd.set_attr_int_list("ksize", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.strides {
                nd.set_attr_int_list("strides", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding {
                nd.set_attr_string("padding", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.data_format {
                nd.set_attr_string("data_format", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'AvgPoolGrad' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        orig_input_shape: crate::Output,
        grad: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<AvgPoolGradInst> {
        let op = scope.new_operation("AvgPoolGrad", |builder| {
            builder.add_input(orig_input_shape);
            builder.add_input(grad);
            if let ::std::option::Option::Some(value) = &self.ksize {
                builder.set_attr_int_list("ksize", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.strides {
                builder.set_attr_int_list("strides", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding {
                builder.set_attr_string("padding", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.data_format {
                builder.set_attr_string("data_format", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(AvgPoolGradInst { op })
    }
}
impl AvgPoolGradInst {
    /// Returns the 'output' Output of this 'AvgPoolGrad' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'orig_input_shape' Input of this 'AvgPoolGrad' operation.
    pub fn orig_input_shape(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'grad' Input of this 'AvgPoolGrad' operation.
    pub fn grad(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<AvgPoolGradInst> for crate::Operation {
    fn from(inst: AvgPoolGradInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `AvgPoolGrad::new().build(orig_input_shape, grad, scope)`.
pub fn avg_pool_grad<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    orig_input_shape: O0,
    grad: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    AvgPoolGrad::new().build(orig_input_shape, grad, scope)
}

/// Builder for the `BandedTriangularSolve` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct BandedTriangularSolve {
    lower: ::std::option::Option<bool>,
    adjoint: ::std::option::Option<bool>,
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'BandedTriangularSolve' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct BandedTriangularSolveInst {
    /// An instance of a fully built BandedTriangularSolve Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl BandedTriangularSolve {
    /// Creates a new `BandedTriangularSolve`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `lower` attribute.
    pub fn lower<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.lower = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `adjoint` attribute.
    pub fn adjoint<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.adjoint = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `BandedTriangularSolve` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        matrix: O0,
        rhs: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(matrix.into(), rhs.into(), scope)
    }
    fn build_impl(
        &self,
        matrix: crate::Output,
        rhs: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("BandedTriangularSolve", |nd| {
            nd.add_input(matrix);
            nd.add_input(rhs);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.lower {
                nd.set_attr_bool("lower", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.adjoint {
                nd.set_attr_bool("adjoint", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'BandedTriangularSolve' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        matrix: crate::Output,
        rhs: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<BandedTriangularSolveInst> {
        let op = scope.new_operation("BandedTriangularSolve", |builder| {
            builder.add_input(matrix);
            builder.add_input(rhs);
            if let ::std::option::Option::Some(value) = &self.lower {
                builder.set_attr_bool("lower", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.adjoint {
                builder.set_attr_bool("adjoint", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(BandedTriangularSolveInst { op })
    }
}
impl BandedTriangularSolveInst {
    /// Returns the 'output' Output of this 'BandedTriangularSolve' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'matrix' Input of this 'BandedTriangularSolve' operation.
    pub fn matrix(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'rhs' Input of this 'BandedTriangularSolve' operation.
    pub fn rhs(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<BandedTriangularSolveInst> for crate::Operation {
    fn from(inst: BandedTriangularSolveInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `BandedTriangularSolve::new().build(matrix, rhs, scope)`.
pub fn banded_triangular_solve<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    matrix: O0,
    rhs: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    BandedTriangularSolve::new().build(matrix, rhs, scope)
}

/// Builder for the `Barrier` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Barrier {
    component_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    capacity: ::std::option::Option<i64>,
    container: ::std::option::Option<::std::string::String>,
    shared_name: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Barrier' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct BarrierInst {
    /// An instance of a fully built Barrier Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Barrier {
    /// Creates a new `Barrier`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `component_types` attribute.
    pub fn component_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.component_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shapes` attribute.
    pub fn shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `capacity` attribute.
    pub fn capacity<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.capacity = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `container` attribute.
    pub fn container<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.container = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shared_name` attribute.
    pub fn shared_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.shared_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Barrier` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("Barrier", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.component_types {
                nd.set_attr_type_list("component_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shapes {
                nd.set_attr_shape_list("shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.capacity {
                nd.set_attr_int("capacity", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.container {
                nd.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                nd.set_attr_string("shared_name", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Barrier' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(&self, scope: &mut crate::Scope) -> crate::Result<BarrierInst> {
        let op = scope.new_operation("Barrier", |builder| {
            if let ::std::option::Option::Some(value) = &self.component_types {
                builder.set_attr_type_list("component_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shapes {
                builder.set_attr_shape_list("shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.capacity {
                builder.set_attr_int("capacity", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.container {
                builder.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                builder.set_attr_string("shared_name", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(BarrierInst { op })
    }
}
impl BarrierInst {
    /// Returns the 'handle' Output of this 'Barrier' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
}
impl From<BarrierInst> for crate::Operation {
    fn from(inst: BarrierInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Barrier::new().build(scope)`.
pub fn barrier(scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
    Barrier::new().build(scope)
}

/// Builder for the `BarrierClose` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct BarrierClose {
    cancel_pending_enqueues: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'BarrierClose' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct BarrierCloseInst {
    /// An instance of a fully built BarrierClose Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl BarrierClose {
    /// Creates a new `BarrierClose`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `cancel_pending_enqueues` attribute.
    pub fn cancel_pending_enqueues<ArgType: ::std::convert::Into<bool>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.cancel_pending_enqueues = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `BarrierClose` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        handle: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(handle.into(), scope)
    }
    fn build_impl(
        &self,
        handle: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("BarrierClose", |nd| {
            nd.add_input(handle);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.cancel_pending_enqueues {
                nd.set_attr_bool("cancel_pending_enqueues", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'BarrierClose' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        handle: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<BarrierCloseInst> {
        let op = scope.new_operation("BarrierClose", |builder| {
            builder.add_input(handle);
            if let ::std::option::Option::Some(value) = &self.cancel_pending_enqueues {
                builder.set_attr_bool("cancel_pending_enqueues", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(BarrierCloseInst { op })
    }
}
impl BarrierCloseInst {
    /// Returns the 'handle' Input of this 'BarrierClose' operation.
    pub fn handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<BarrierCloseInst> for crate::Operation {
    fn from(inst: BarrierCloseInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `BarrierClose::new().build(handle, scope)`.
pub fn barrier_close<O0: ::std::convert::Into<crate::Output>>(
    handle: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    BarrierClose::new().build(handle, scope)
}

/// Builder for the `BarrierIncompleteSize` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct BarrierIncompleteSize {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'BarrierIncompleteSize' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct BarrierIncompleteSizeInst {
    /// An instance of a fully built BarrierIncompleteSize Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl BarrierIncompleteSize {
    /// Creates a new `BarrierIncompleteSize`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `BarrierIncompleteSize` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        handle: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(handle.into(), scope)
    }
    fn build_impl(
        &self,
        handle: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("BarrierIncompleteSize", |nd| {
            nd.add_input(handle);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'BarrierIncompleteSize' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        handle: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<BarrierIncompleteSizeInst> {
        let op = scope.new_operation("BarrierIncompleteSize", |builder| {
            builder.add_input(handle);
            ::std::result::Result::Ok(())
        })?;
        Ok(BarrierIncompleteSizeInst { op })
    }
}
impl BarrierIncompleteSizeInst {
    /// Returns the 'size' Output of this 'BarrierIncompleteSize' operation.
    pub fn size(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'handle' Input of this 'BarrierIncompleteSize' operation.
    pub fn handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<BarrierIncompleteSizeInst> for crate::Operation {
    fn from(inst: BarrierIncompleteSizeInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `BarrierIncompleteSize::new().build(handle, scope)`.
pub fn barrier_incomplete_size<O0: ::std::convert::Into<crate::Output>>(
    handle: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    BarrierIncompleteSize::new().build(handle, scope)
}

/// Builder for the `BarrierInsertMany` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct BarrierInsertMany {
    T: ::std::option::Option<crate::DataType>,
    component_index: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'BarrierInsertMany' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct BarrierInsertManyInst {
    /// An instance of a fully built BarrierInsertMany Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl BarrierInsertMany {
    /// Creates a new `BarrierInsertMany`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `component_index` attribute.
    pub fn component_index<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.component_index = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `BarrierInsertMany` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        handle: O0,
        keys: O1,
        values: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(handle.into(), keys.into(), values.into(), scope)
    }
    fn build_impl(
        &self,
        handle: crate::Output,
        keys: crate::Output,
        values: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("BarrierInsertMany", |nd| {
            nd.add_input(handle);
            nd.add_input(keys);
            nd.add_input(values);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.component_index {
                nd.set_attr_int("component_index", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'BarrierInsertMany' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        handle: crate::Output,
        keys: crate::Output,
        values: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<BarrierInsertManyInst> {
        let op = scope.new_operation("BarrierInsertMany", |builder| {
            builder.add_input(handle);
            builder.add_input(keys);
            builder.add_input(values);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.component_index {
                builder.set_attr_int("component_index", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(BarrierInsertManyInst { op })
    }
}
impl BarrierInsertManyInst {
    /// Returns the 'handle' Input of this 'BarrierInsertMany' operation.
    pub fn handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'keys' Input of this 'BarrierInsertMany' operation.
    pub fn keys(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'values' Input of this 'BarrierInsertMany' operation.
    pub fn values(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<BarrierInsertManyInst> for crate::Operation {
    fn from(inst: BarrierInsertManyInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `BarrierInsertMany::new().build(handle, keys, values, scope)`.
pub fn barrier_insert_many<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    handle: O0,
    keys: O1,
    values: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    BarrierInsertMany::new().build(handle, keys, values, scope)
}

/// Builder for the `BarrierReadySize` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct BarrierReadySize {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'BarrierReadySize' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct BarrierReadySizeInst {
    /// An instance of a fully built BarrierReadySize Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl BarrierReadySize {
    /// Creates a new `BarrierReadySize`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `BarrierReadySize` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        handle: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(handle.into(), scope)
    }
    fn build_impl(
        &self,
        handle: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("BarrierReadySize", |nd| {
            nd.add_input(handle);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'BarrierReadySize' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        handle: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<BarrierReadySizeInst> {
        let op = scope.new_operation("BarrierReadySize", |builder| {
            builder.add_input(handle);
            ::std::result::Result::Ok(())
        })?;
        Ok(BarrierReadySizeInst { op })
    }
}
impl BarrierReadySizeInst {
    /// Returns the 'size' Output of this 'BarrierReadySize' operation.
    pub fn size(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'handle' Input of this 'BarrierReadySize' operation.
    pub fn handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<BarrierReadySizeInst> for crate::Operation {
    fn from(inst: BarrierReadySizeInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `BarrierReadySize::new().build(handle, scope)`.
pub fn barrier_ready_size<O0: ::std::convert::Into<crate::Output>>(
    handle: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    BarrierReadySize::new().build(handle, scope)
}

/// Builder for the `BarrierTakeMany` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct BarrierTakeMany {
    component_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    allow_small_batch: ::std::option::Option<bool>,
    wait_for_incomplete: ::std::option::Option<bool>,
    timeout_ms: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'BarrierTakeMany' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct BarrierTakeManyInst {
    /// An instance of a fully built BarrierTakeMany Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl BarrierTakeMany {
    /// Creates a new `BarrierTakeMany`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `component_types` attribute.
    pub fn component_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.component_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `allow_small_batch` attribute.
    pub fn allow_small_batch<ArgType: ::std::convert::Into<bool>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.allow_small_batch = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `wait_for_incomplete` attribute.
    pub fn wait_for_incomplete<ArgType: ::std::convert::Into<bool>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.wait_for_incomplete = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `timeout_ms` attribute.
    pub fn timeout_ms<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.timeout_ms = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `BarrierTakeMany` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        handle: O0,
        num_elements: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(handle.into(), num_elements.into(), scope)
    }
    fn build_impl(
        &self,
        handle: crate::Output,
        num_elements: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("BarrierTakeMany", |nd| {
            nd.add_input(handle);
            nd.add_input(num_elements);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.component_types {
                nd.set_attr_type_list("component_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.allow_small_batch {
                nd.set_attr_bool("allow_small_batch", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.wait_for_incomplete {
                nd.set_attr_bool("wait_for_incomplete", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.timeout_ms {
                nd.set_attr_int("timeout_ms", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'BarrierTakeMany' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        handle: crate::Output,
        num_elements: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<BarrierTakeManyInst> {
        let op = scope.new_operation("BarrierTakeMany", |builder| {
            builder.add_input(handle);
            builder.add_input(num_elements);
            if let ::std::option::Option::Some(value) = &self.component_types {
                builder.set_attr_type_list("component_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.allow_small_batch {
                builder.set_attr_bool("allow_small_batch", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.wait_for_incomplete {
                builder.set_attr_bool("wait_for_incomplete", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.timeout_ms {
                builder.set_attr_int("timeout_ms", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(BarrierTakeManyInst { op })
    }
}
impl BarrierTakeManyInst {
    /// Returns the 'indices' Output of this 'BarrierTakeMany' operation.
    pub fn indices(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'keys' Output of this 'BarrierTakeMany' operation.
    pub fn keys(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'values' Output of this 'BarrierTakeMany' operation.
    pub fn values(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns the 'handle' Input of this 'BarrierTakeMany' operation.
    pub fn handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'num_elements' Input of this 'BarrierTakeMany' operation.
    pub fn num_elements(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<BarrierTakeManyInst> for crate::Operation {
    fn from(inst: BarrierTakeManyInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `BarrierTakeMany::new().build(handle, num_elements, scope)`.
pub fn barrier_take_many<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    handle: O0,
    num_elements: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    BarrierTakeMany::new().build(handle, num_elements, scope)
}

/// Builder for the `Batch` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Batch {
    num_batch_threads: ::std::option::Option<i64>,
    max_batch_size: ::std::option::Option<i64>,
    max_enqueued_batches: ::std::option::Option<i64>,
    batch_timeout_micros: ::std::option::Option<i64>,
    allowed_batch_sizes: ::std::option::Option<::std::vec::Vec<i64>>,
    grad_timeout_micros: ::std::option::Option<i64>,
    container: ::std::option::Option<::std::string::String>,
    shared_name: ::std::option::Option<::std::string::String>,
    batching_queue: ::std::option::Option<::std::string::String>,
    T: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Batch' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct BatchInst {
    /// An instance of a fully built Batch Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Batch {
    /// Creates a new `Batch`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `num_batch_threads` attribute.
    pub fn num_batch_threads<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.num_batch_threads = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `max_batch_size` attribute.
    pub fn max_batch_size<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.max_batch_size = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `max_enqueued_batches` attribute.
    pub fn max_enqueued_batches<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.max_enqueued_batches = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `batch_timeout_micros` attribute.
    pub fn batch_timeout_micros<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.batch_timeout_micros = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `allowed_batch_sizes` attribute.
    pub fn allowed_batch_sizes<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.allowed_batch_sizes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `grad_timeout_micros` attribute.
    pub fn grad_timeout_micros<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.grad_timeout_micros = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `container` attribute.
    pub fn container<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.container = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shared_name` attribute.
    pub fn shared_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.shared_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `batching_queue` attribute.
    pub fn batching_queue<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.batching_queue = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Batch` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        in_tensors: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(in_tensors.into(), scope)
    }
    fn build_impl(
        &self,
        in_tensors: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Batch", |nd| {
            nd.add_input(in_tensors);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.num_batch_threads {
                nd.set_attr_int("num_batch_threads", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.max_batch_size {
                nd.set_attr_int("max_batch_size", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.max_enqueued_batches {
                nd.set_attr_int("max_enqueued_batches", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.batch_timeout_micros {
                nd.set_attr_int("batch_timeout_micros", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.allowed_batch_sizes {
                nd.set_attr_int_list("allowed_batch_sizes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.grad_timeout_micros {
                nd.set_attr_int("grad_timeout_micros", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.container {
                nd.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                nd.set_attr_string("shared_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.batching_queue {
                nd.set_attr_string("batching_queue", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type_list("T", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Batch' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        in_tensors: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<BatchInst> {
        let op = scope.new_operation("Batch", |builder| {
            builder.add_input(in_tensors);
            if let ::std::option::Option::Some(value) = &self.num_batch_threads {
                builder.set_attr_int("num_batch_threads", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.max_batch_size {
                builder.set_attr_int("max_batch_size", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.max_enqueued_batches {
                builder.set_attr_int("max_enqueued_batches", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.batch_timeout_micros {
                builder.set_attr_int("batch_timeout_micros", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.allowed_batch_sizes {
                builder.set_attr_int_list("allowed_batch_sizes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.grad_timeout_micros {
                builder.set_attr_int("grad_timeout_micros", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.container {
                builder.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                builder.set_attr_string("shared_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.batching_queue {
                builder.set_attr_string("batching_queue", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type_list("T", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(BatchInst { op })
    }
}
impl BatchInst {
    /// Returns the 'batched_tensors' Output of this 'Batch' operation.
    pub fn batched_tensors(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'batch_index' Output of this 'Batch' operation.
    pub fn batch_index(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'id' Output of this 'Batch' operation.
    pub fn id(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns the 'in_tensors' Input of this 'Batch' operation.
    pub fn in_tensors(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<BatchInst> for crate::Operation {
    fn from(inst: BatchInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Batch::new().build(in_tensors, scope)`.
pub fn batch<O0: ::std::convert::Into<crate::Output>>(
    in_tensors: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Batch::new().build(in_tensors, scope)
}

/// Builder for the `BatchCholesky` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct BatchCholesky {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'BatchCholesky' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct BatchCholeskyInst {
    /// An instance of a fully built BatchCholesky Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl BatchCholesky {
    /// Creates a new `BatchCholesky`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `BatchCholesky` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("BatchCholesky", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'BatchCholesky' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<BatchCholeskyInst> {
        let op = scope.new_operation("BatchCholesky", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(BatchCholeskyInst { op })
    }
}
impl BatchCholeskyInst {
    /// Returns the 'output' Output of this 'BatchCholesky' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'BatchCholesky' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<BatchCholeskyInst> for crate::Operation {
    fn from(inst: BatchCholeskyInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `BatchCholesky::new().build(input, scope)`.
pub fn batch_cholesky<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    BatchCholesky::new().build(input, scope)
}

/// Builder for the `BatchCholeskyGrad` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct BatchCholeskyGrad {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'BatchCholeskyGrad' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct BatchCholeskyGradInst {
    /// An instance of a fully built BatchCholeskyGrad Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl BatchCholeskyGrad {
    /// Creates a new `BatchCholeskyGrad`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `BatchCholeskyGrad` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        l: O0,
        grad: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(l.into(), grad.into(), scope)
    }
    fn build_impl(
        &self,
        l: crate::Output,
        grad: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("BatchCholeskyGrad", |nd| {
            nd.add_input(l);
            nd.add_input(grad);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'BatchCholeskyGrad' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        l: crate::Output,
        grad: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<BatchCholeskyGradInst> {
        let op = scope.new_operation("BatchCholeskyGrad", |builder| {
            builder.add_input(l);
            builder.add_input(grad);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(BatchCholeskyGradInst { op })
    }
}
impl BatchCholeskyGradInst {
    /// Returns the 'output' Output of this 'BatchCholeskyGrad' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'l' Input of this 'BatchCholeskyGrad' operation.
    pub fn l(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'grad' Input of this 'BatchCholeskyGrad' operation.
    pub fn grad(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<BatchCholeskyGradInst> for crate::Operation {
    fn from(inst: BatchCholeskyGradInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `BatchCholeskyGrad::new().build(l, grad, scope)`.
pub fn batch_cholesky_grad<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    l: O0,
    grad: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    BatchCholeskyGrad::new().build(l, grad, scope)
}

/// Builder for the `BatchDataset` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct BatchDataset {
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    metadata: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'BatchDataset' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct BatchDatasetInst {
    /// An instance of a fully built BatchDataset Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl BatchDataset {
    /// Creates a new `BatchDataset`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `metadata` attribute.
    pub fn metadata<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.metadata = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `BatchDataset` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input_dataset: O0,
        batch_size: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input_dataset.into(), batch_size.into(), scope)
    }
    fn build_impl(
        &self,
        input_dataset: crate::Output,
        batch_size: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("BatchDataset", |nd| {
            nd.add_input(input_dataset);
            nd.add_input(batch_size);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.metadata {
                nd.set_attr_string("metadata", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'BatchDataset' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_dataset: crate::Output,
        batch_size: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<BatchDatasetInst> {
        let op = scope.new_operation("BatchDataset", |builder| {
            builder.add_input(input_dataset);
            builder.add_input(batch_size);
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.metadata {
                builder.set_attr_string("metadata", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(BatchDatasetInst { op })
    }
}
impl BatchDatasetInst {
    /// Returns the 'handle' Output of this 'BatchDataset' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_dataset' Input of this 'BatchDataset' operation.
    pub fn input_dataset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'batch_size' Input of this 'BatchDataset' operation.
    pub fn batch_size(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<BatchDatasetInst> for crate::Operation {
    fn from(inst: BatchDatasetInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `BatchDataset::new().build(input_dataset, batch_size, scope)`.
pub fn batch_dataset<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    input_dataset: O0,
    batch_size: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    BatchDataset::new().build(input_dataset, batch_size, scope)
}

/// Builder for the `BatchDatasetV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct BatchDatasetV2 {
    parallel_copy: ::std::option::Option<bool>,
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    metadata: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'BatchDatasetV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct BatchDatasetV2Inst {
    /// An instance of a fully built BatchDatasetV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl BatchDatasetV2 {
    /// Creates a new `BatchDatasetV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `parallel_copy` attribute.
    pub fn parallel_copy<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.parallel_copy = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `metadata` attribute.
    pub fn metadata<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.metadata = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `BatchDatasetV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input_dataset: O0,
        batch_size: O1,
        drop_remainder: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            input_dataset.into(),
            batch_size.into(),
            drop_remainder.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        input_dataset: crate::Output,
        batch_size: crate::Output,
        drop_remainder: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("BatchDatasetV2", |nd| {
            nd.add_input(input_dataset);
            nd.add_input(batch_size);
            nd.add_input(drop_remainder);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.parallel_copy {
                nd.set_attr_bool("parallel_copy", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.metadata {
                nd.set_attr_string("metadata", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'BatchDatasetV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_dataset: crate::Output,
        batch_size: crate::Output,
        drop_remainder: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<BatchDatasetV2Inst> {
        let op = scope.new_operation("BatchDatasetV2", |builder| {
            builder.add_input(input_dataset);
            builder.add_input(batch_size);
            builder.add_input(drop_remainder);
            if let ::std::option::Option::Some(value) = &self.parallel_copy {
                builder.set_attr_bool("parallel_copy", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.metadata {
                builder.set_attr_string("metadata", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(BatchDatasetV2Inst { op })
    }
}
impl BatchDatasetV2Inst {
    /// Returns the 'handle' Output of this 'BatchDatasetV2' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_dataset' Input of this 'BatchDatasetV2' operation.
    pub fn input_dataset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'batch_size' Input of this 'BatchDatasetV2' operation.
    pub fn batch_size(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'drop_remainder' Input of this 'BatchDatasetV2' operation.
    pub fn drop_remainder(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<BatchDatasetV2Inst> for crate::Operation {
    fn from(inst: BatchDatasetV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `BatchDatasetV2::new().build(input_dataset, batch_size, drop_remainder, scope)`.
pub fn batch_dataset_v2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    input_dataset: O0,
    batch_size: O1,
    drop_remainder: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    BatchDatasetV2::new().build(input_dataset, batch_size, drop_remainder, scope)
}

/// Builder for the `BatchFFT` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct BatchFFT {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'BatchFFT' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct BatchFFTInst {
    /// An instance of a fully built BatchFFT Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl BatchFFT {
    /// Creates a new `BatchFFT`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `BatchFFT` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("BatchFFT", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'BatchFFT' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<BatchFFTInst> {
        let op = scope.new_operation("BatchFFT", |builder| {
            builder.add_input(input);
            ::std::result::Result::Ok(())
        })?;
        Ok(BatchFFTInst { op })
    }
}
impl BatchFFTInst {
    /// Returns the 'output' Output of this 'BatchFFT' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'BatchFFT' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<BatchFFTInst> for crate::Operation {
    fn from(inst: BatchFFTInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `BatchFFT::new().build(input, scope)`.
pub fn batch_fft<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    BatchFFT::new().build(input, scope)
}

/// Builder for the `BatchFFT2D` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct BatchFFT2D {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'BatchFFT2D' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct BatchFFT2DInst {
    /// An instance of a fully built BatchFFT2D Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl BatchFFT2D {
    /// Creates a new `BatchFFT2D`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `BatchFFT2D` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("BatchFFT2D", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'BatchFFT2D' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<BatchFFT2DInst> {
        let op = scope.new_operation("BatchFFT2D", |builder| {
            builder.add_input(input);
            ::std::result::Result::Ok(())
        })?;
        Ok(BatchFFT2DInst { op })
    }
}
impl BatchFFT2DInst {
    /// Returns the 'output' Output of this 'BatchFFT2D' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'BatchFFT2D' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<BatchFFT2DInst> for crate::Operation {
    fn from(inst: BatchFFT2DInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `BatchFFT2D::new().build(input, scope)`.
pub fn batch_fft2_d<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    BatchFFT2D::new().build(input, scope)
}

/// Builder for the `BatchFFT3D` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct BatchFFT3D {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'BatchFFT3D' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct BatchFFT3DInst {
    /// An instance of a fully built BatchFFT3D Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl BatchFFT3D {
    /// Creates a new `BatchFFT3D`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `BatchFFT3D` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("BatchFFT3D", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'BatchFFT3D' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<BatchFFT3DInst> {
        let op = scope.new_operation("BatchFFT3D", |builder| {
            builder.add_input(input);
            ::std::result::Result::Ok(())
        })?;
        Ok(BatchFFT3DInst { op })
    }
}
impl BatchFFT3DInst {
    /// Returns the 'output' Output of this 'BatchFFT3D' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'BatchFFT3D' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<BatchFFT3DInst> for crate::Operation {
    fn from(inst: BatchFFT3DInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `BatchFFT3D::new().build(input, scope)`.
pub fn batch_fft3_d<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    BatchFFT3D::new().build(input, scope)
}

/// Builder for the `BatchFunction` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct BatchFunction {
    f: ::std::option::Option<::std::string::String>,
    num_batch_threads: ::std::option::Option<i64>,
    max_batch_size: ::std::option::Option<i64>,
    batch_timeout_micros: ::std::option::Option<i64>,
    max_enqueued_batches: ::std::option::Option<i64>,
    allowed_batch_sizes: ::std::option::Option<::std::vec::Vec<i64>>,
    container: ::std::option::Option<::std::string::String>,
    shared_name: ::std::option::Option<::std::string::String>,
    batching_queue: ::std::option::Option<::std::string::String>,
    Tin: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    Tcaptured: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    Tout: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    enable_large_batch_splitting: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'BatchFunction' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct BatchFunctionInst {
    /// An instance of a fully built BatchFunction Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl BatchFunction {
    /// Creates a new `BatchFunction`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `f` attribute.
    pub fn f<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.f = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `num_batch_threads` attribute.
    pub fn num_batch_threads<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.num_batch_threads = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `max_batch_size` attribute.
    pub fn max_batch_size<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.max_batch_size = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `batch_timeout_micros` attribute.
    pub fn batch_timeout_micros<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.batch_timeout_micros = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `max_enqueued_batches` attribute.
    pub fn max_enqueued_batches<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.max_enqueued_batches = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `allowed_batch_sizes` attribute.
    pub fn allowed_batch_sizes<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.allowed_batch_sizes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `container` attribute.
    pub fn container<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.container = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shared_name` attribute.
    pub fn shared_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.shared_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `batching_queue` attribute.
    pub fn batching_queue<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.batching_queue = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tin` attribute.
    pub fn Tin<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tin = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tcaptured` attribute.
    pub fn Tcaptured<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tcaptured = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tout` attribute.
    pub fn Tout<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tout = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `enable_large_batch_splitting` attribute.
    pub fn enable_large_batch_splitting<ArgType: ::std::convert::Into<bool>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.enable_large_batch_splitting = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `BatchFunction` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        in_tensors: O0,
        captured_tensors: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(in_tensors.into(), captured_tensors.into(), scope)
    }
    fn build_impl(
        &self,
        in_tensors: crate::Output,
        captured_tensors: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("BatchFunction", |nd| {
            nd.add_input(in_tensors);
            nd.add_input(captured_tensors);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.f {
                nd.set_attr_string("f", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_batch_threads {
                nd.set_attr_int("num_batch_threads", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.max_batch_size {
                nd.set_attr_int("max_batch_size", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.batch_timeout_micros {
                nd.set_attr_int("batch_timeout_micros", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.max_enqueued_batches {
                nd.set_attr_int("max_enqueued_batches", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.allowed_batch_sizes {
                nd.set_attr_int_list("allowed_batch_sizes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.container {
                nd.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                nd.set_attr_string("shared_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.batching_queue {
                nd.set_attr_string("batching_queue", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tin {
                nd.set_attr_type_list("Tin", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tcaptured {
                nd.set_attr_type_list("Tcaptured", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tout {
                nd.set_attr_type_list("Tout", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.enable_large_batch_splitting {
                nd.set_attr_bool("enable_large_batch_splitting", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'BatchFunction' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        in_tensors: crate::Output,
        captured_tensors: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<BatchFunctionInst> {
        let op = scope.new_operation("BatchFunction", |builder| {
            builder.add_input(in_tensors);
            builder.add_input(captured_tensors);
            if let ::std::option::Option::Some(value) = &self.f {
                builder.set_attr_string("f", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_batch_threads {
                builder.set_attr_int("num_batch_threads", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.max_batch_size {
                builder.set_attr_int("max_batch_size", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.batch_timeout_micros {
                builder.set_attr_int("batch_timeout_micros", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.max_enqueued_batches {
                builder.set_attr_int("max_enqueued_batches", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.allowed_batch_sizes {
                builder.set_attr_int_list("allowed_batch_sizes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.container {
                builder.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                builder.set_attr_string("shared_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.batching_queue {
                builder.set_attr_string("batching_queue", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tin {
                builder.set_attr_type_list("Tin", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tcaptured {
                builder.set_attr_type_list("Tcaptured", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tout {
                builder.set_attr_type_list("Tout", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.enable_large_batch_splitting {
                builder.set_attr_bool("enable_large_batch_splitting", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(BatchFunctionInst { op })
    }
}
impl BatchFunctionInst {
    /// Returns the 'out_tensors' Output of this 'BatchFunction' operation.
    pub fn out_tensors(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'in_tensors' Input of this 'BatchFunction' operation.
    pub fn in_tensors(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'captured_tensors' Input of this 'BatchFunction' operation.
    pub fn captured_tensors(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<BatchFunctionInst> for crate::Operation {
    fn from(inst: BatchFunctionInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `BatchFunction::new().build(in_tensors, captured_tensors, scope)`.
pub fn batch_function<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    in_tensors: O0,
    captured_tensors: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    BatchFunction::new().build(in_tensors, captured_tensors, scope)
}

/// Builder for the `BatchIFFT` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct BatchIFFT {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'BatchIFFT' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct BatchIFFTInst {
    /// An instance of a fully built BatchIFFT Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl BatchIFFT {
    /// Creates a new `BatchIFFT`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `BatchIFFT` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("BatchIFFT", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'BatchIFFT' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<BatchIFFTInst> {
        let op = scope.new_operation("BatchIFFT", |builder| {
            builder.add_input(input);
            ::std::result::Result::Ok(())
        })?;
        Ok(BatchIFFTInst { op })
    }
}
impl BatchIFFTInst {
    /// Returns the 'output' Output of this 'BatchIFFT' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'BatchIFFT' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<BatchIFFTInst> for crate::Operation {
    fn from(inst: BatchIFFTInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `BatchIFFT::new().build(input, scope)`.
pub fn batch_ifft<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    BatchIFFT::new().build(input, scope)
}

/// Builder for the `BatchIFFT2D` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct BatchIFFT2D {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'BatchIFFT2D' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct BatchIFFT2DInst {
    /// An instance of a fully built BatchIFFT2D Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl BatchIFFT2D {
    /// Creates a new `BatchIFFT2D`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `BatchIFFT2D` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("BatchIFFT2D", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'BatchIFFT2D' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<BatchIFFT2DInst> {
        let op = scope.new_operation("BatchIFFT2D", |builder| {
            builder.add_input(input);
            ::std::result::Result::Ok(())
        })?;
        Ok(BatchIFFT2DInst { op })
    }
}
impl BatchIFFT2DInst {
    /// Returns the 'output' Output of this 'BatchIFFT2D' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'BatchIFFT2D' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<BatchIFFT2DInst> for crate::Operation {
    fn from(inst: BatchIFFT2DInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `BatchIFFT2D::new().build(input, scope)`.
pub fn batch_ifft2_d<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    BatchIFFT2D::new().build(input, scope)
}

/// Builder for the `BatchIFFT3D` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct BatchIFFT3D {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'BatchIFFT3D' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct BatchIFFT3DInst {
    /// An instance of a fully built BatchIFFT3D Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl BatchIFFT3D {
    /// Creates a new `BatchIFFT3D`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `BatchIFFT3D` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("BatchIFFT3D", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'BatchIFFT3D' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<BatchIFFT3DInst> {
        let op = scope.new_operation("BatchIFFT3D", |builder| {
            builder.add_input(input);
            ::std::result::Result::Ok(())
        })?;
        Ok(BatchIFFT3DInst { op })
    }
}
impl BatchIFFT3DInst {
    /// Returns the 'output' Output of this 'BatchIFFT3D' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'BatchIFFT3D' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<BatchIFFT3DInst> for crate::Operation {
    fn from(inst: BatchIFFT3DInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `BatchIFFT3D::new().build(input, scope)`.
pub fn batch_ifft3_d<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    BatchIFFT3D::new().build(input, scope)
}

/// Builder for the `BatchMatMul` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct BatchMatMul {
    T: ::std::option::Option<crate::DataType>,
    adj_x: ::std::option::Option<bool>,
    adj_y: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'BatchMatMul' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct BatchMatMulInst {
    /// An instance of a fully built BatchMatMul Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl BatchMatMul {
    /// Creates a new `BatchMatMul`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `adj_x` attribute.
    pub fn adj_x<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.adj_x = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `adj_y` attribute.
    pub fn adj_y<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.adj_y = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `BatchMatMul` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        x: O0,
        y: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), y.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        y: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("BatchMatMul", |nd| {
            nd.add_input(x);
            nd.add_input(y);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.adj_x {
                nd.set_attr_bool("adj_x", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.adj_y {
                nd.set_attr_bool("adj_y", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'BatchMatMul' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        y: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<BatchMatMulInst> {
        let op = scope.new_operation("BatchMatMul", |builder| {
            builder.add_input(x);
            builder.add_input(y);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.adj_x {
                builder.set_attr_bool("adj_x", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.adj_y {
                builder.set_attr_bool("adj_y", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(BatchMatMulInst { op })
    }
}
impl BatchMatMulInst {
    /// Returns the 'output' Output of this 'BatchMatMul' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'BatchMatMul' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'y' Input of this 'BatchMatMul' operation.
    pub fn y(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<BatchMatMulInst> for crate::Operation {
    fn from(inst: BatchMatMulInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `BatchMatMul::new().build(x, y, scope)`.
pub fn batch_mat_mul<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    x: O0,
    y: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    BatchMatMul::new().build(x, y, scope)
}

/// Builder for the `BatchMatMulV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct BatchMatMulV2 {
    T: ::std::option::Option<crate::DataType>,
    adj_x: ::std::option::Option<bool>,
    adj_y: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'BatchMatMulV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct BatchMatMulV2Inst {
    /// An instance of a fully built BatchMatMulV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl BatchMatMulV2 {
    /// Creates a new `BatchMatMulV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `adj_x` attribute.
    pub fn adj_x<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.adj_x = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `adj_y` attribute.
    pub fn adj_y<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.adj_y = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `BatchMatMulV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        x: O0,
        y: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), y.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        y: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("BatchMatMulV2", |nd| {
            nd.add_input(x);
            nd.add_input(y);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.adj_x {
                nd.set_attr_bool("adj_x", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.adj_y {
                nd.set_attr_bool("adj_y", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'BatchMatMulV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        y: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<BatchMatMulV2Inst> {
        let op = scope.new_operation("BatchMatMulV2", |builder| {
            builder.add_input(x);
            builder.add_input(y);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.adj_x {
                builder.set_attr_bool("adj_x", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.adj_y {
                builder.set_attr_bool("adj_y", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(BatchMatMulV2Inst { op })
    }
}
impl BatchMatMulV2Inst {
    /// Returns the 'output' Output of this 'BatchMatMulV2' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'BatchMatMulV2' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'y' Input of this 'BatchMatMulV2' operation.
    pub fn y(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<BatchMatMulV2Inst> for crate::Operation {
    fn from(inst: BatchMatMulV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `BatchMatMulV2::new().build(x, y, scope)`.
pub fn batch_mat_mul_v2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    x: O0,
    y: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    BatchMatMulV2::new().build(x, y, scope)
}

/// Builder for the `BatchMatMulV3` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct BatchMatMulV3 {
    Ta: ::std::option::Option<crate::DataType>,
    Tb: ::std::option::Option<crate::DataType>,
    Tout: ::std::option::Option<crate::DataType>,
    adj_x: ::std::option::Option<bool>,
    adj_y: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'BatchMatMulV3' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct BatchMatMulV3Inst {
    /// An instance of a fully built BatchMatMulV3 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl BatchMatMulV3 {
    /// Creates a new `BatchMatMulV3`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `Ta` attribute.
    pub fn Ta<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Ta = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tb` attribute.
    pub fn Tb<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Tb = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tout` attribute.
    pub fn Tout<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Tout = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `adj_x` attribute.
    pub fn adj_x<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.adj_x = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `adj_y` attribute.
    pub fn adj_y<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.adj_y = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `BatchMatMulV3` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        x: O0,
        y: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), y.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        y: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("BatchMatMulV3", |nd| {
            nd.add_input(x);
            nd.add_input(y);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.Ta {
                nd.set_attr_type("Ta", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tb {
                nd.set_attr_type("Tb", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tout {
                nd.set_attr_type("Tout", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.adj_x {
                nd.set_attr_bool("adj_x", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.adj_y {
                nd.set_attr_bool("adj_y", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'BatchMatMulV3' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        y: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<BatchMatMulV3Inst> {
        let op = scope.new_operation("BatchMatMulV3", |builder| {
            builder.add_input(x);
            builder.add_input(y);
            if let ::std::option::Option::Some(value) = &self.Ta {
                builder.set_attr_type("Ta", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tb {
                builder.set_attr_type("Tb", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tout {
                builder.set_attr_type("Tout", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.adj_x {
                builder.set_attr_bool("adj_x", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.adj_y {
                builder.set_attr_bool("adj_y", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(BatchMatMulV3Inst { op })
    }
}
impl BatchMatMulV3Inst {
    /// Returns the 'output' Output of this 'BatchMatMulV3' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'BatchMatMulV3' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'y' Input of this 'BatchMatMulV3' operation.
    pub fn y(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<BatchMatMulV3Inst> for crate::Operation {
    fn from(inst: BatchMatMulV3Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `BatchMatMulV3::new().build(x, y, scope)`.
pub fn batch_mat_mul_v3<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    x: O0,
    y: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    BatchMatMulV3::new().build(x, y, scope)
}

/// Builder for the `BatchMatrixBandPart` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct BatchMatrixBandPart {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'BatchMatrixBandPart' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct BatchMatrixBandPartInst {
    /// An instance of a fully built BatchMatrixBandPart Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl BatchMatrixBandPart {
    /// Creates a new `BatchMatrixBandPart`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `BatchMatrixBandPart` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        num_lower: O1,
        num_upper: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), num_lower.into(), num_upper.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        num_lower: crate::Output,
        num_upper: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("BatchMatrixBandPart", |nd| {
            nd.add_input(input);
            nd.add_input(num_lower);
            nd.add_input(num_upper);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'BatchMatrixBandPart' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        num_lower: crate::Output,
        num_upper: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<BatchMatrixBandPartInst> {
        let op = scope.new_operation("BatchMatrixBandPart", |builder| {
            builder.add_input(input);
            builder.add_input(num_lower);
            builder.add_input(num_upper);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(BatchMatrixBandPartInst { op })
    }
}
impl BatchMatrixBandPartInst {
    /// Returns the 'band' Output of this 'BatchMatrixBandPart' operation.
    pub fn band(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'BatchMatrixBandPart' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'num_lower' Input of this 'BatchMatrixBandPart' operation.
    pub fn num_lower(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'num_upper' Input of this 'BatchMatrixBandPart' operation.
    pub fn num_upper(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<BatchMatrixBandPartInst> for crate::Operation {
    fn from(inst: BatchMatrixBandPartInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `BatchMatrixBandPart::new().build(input, num_lower, num_upper, scope)`.
pub fn batch_matrix_band_part<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    input: O0,
    num_lower: O1,
    num_upper: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    BatchMatrixBandPart::new().build(input, num_lower, num_upper, scope)
}

/// Builder for the `BatchMatrixDeterminant` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct BatchMatrixDeterminant {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'BatchMatrixDeterminant' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct BatchMatrixDeterminantInst {
    /// An instance of a fully built BatchMatrixDeterminant Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl BatchMatrixDeterminant {
    /// Creates a new `BatchMatrixDeterminant`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `BatchMatrixDeterminant` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("BatchMatrixDeterminant", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'BatchMatrixDeterminant' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<BatchMatrixDeterminantInst> {
        let op = scope.new_operation("BatchMatrixDeterminant", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(BatchMatrixDeterminantInst { op })
    }
}
impl BatchMatrixDeterminantInst {
    /// Returns the 'output' Output of this 'BatchMatrixDeterminant' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'BatchMatrixDeterminant' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<BatchMatrixDeterminantInst> for crate::Operation {
    fn from(inst: BatchMatrixDeterminantInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `BatchMatrixDeterminant::new().build(input, scope)`.
pub fn batch_matrix_determinant<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    BatchMatrixDeterminant::new().build(input, scope)
}

/// Builder for the `BatchMatrixDiag` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct BatchMatrixDiag {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'BatchMatrixDiag' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct BatchMatrixDiagInst {
    /// An instance of a fully built BatchMatrixDiag Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl BatchMatrixDiag {
    /// Creates a new `BatchMatrixDiag`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `BatchMatrixDiag` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        diagonal: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(diagonal.into(), scope)
    }
    fn build_impl(
        &self,
        diagonal: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("BatchMatrixDiag", |nd| {
            nd.add_input(diagonal);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'BatchMatrixDiag' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        diagonal: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<BatchMatrixDiagInst> {
        let op = scope.new_operation("BatchMatrixDiag", |builder| {
            builder.add_input(diagonal);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(BatchMatrixDiagInst { op })
    }
}
impl BatchMatrixDiagInst {
    /// Returns the 'output' Output of this 'BatchMatrixDiag' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'diagonal' Input of this 'BatchMatrixDiag' operation.
    pub fn diagonal(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<BatchMatrixDiagInst> for crate::Operation {
    fn from(inst: BatchMatrixDiagInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `BatchMatrixDiag::new().build(diagonal, scope)`.
pub fn batch_matrix_diag<O0: ::std::convert::Into<crate::Output>>(
    diagonal: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    BatchMatrixDiag::new().build(diagonal, scope)
}

/// Builder for the `BatchMatrixDiagPart` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct BatchMatrixDiagPart {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'BatchMatrixDiagPart' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct BatchMatrixDiagPartInst {
    /// An instance of a fully built BatchMatrixDiagPart Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl BatchMatrixDiagPart {
    /// Creates a new `BatchMatrixDiagPart`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `BatchMatrixDiagPart` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("BatchMatrixDiagPart", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'BatchMatrixDiagPart' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<BatchMatrixDiagPartInst> {
        let op = scope.new_operation("BatchMatrixDiagPart", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(BatchMatrixDiagPartInst { op })
    }
}
impl BatchMatrixDiagPartInst {
    /// Returns the 'diagonal' Output of this 'BatchMatrixDiagPart' operation.
    pub fn diagonal(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'BatchMatrixDiagPart' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<BatchMatrixDiagPartInst> for crate::Operation {
    fn from(inst: BatchMatrixDiagPartInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `BatchMatrixDiagPart::new().build(input, scope)`.
pub fn batch_matrix_diag_part<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    BatchMatrixDiagPart::new().build(input, scope)
}

/// Builder for the `BatchMatrixInverse` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct BatchMatrixInverse {
    adjoint: ::std::option::Option<bool>,
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'BatchMatrixInverse' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct BatchMatrixInverseInst {
    /// An instance of a fully built BatchMatrixInverse Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl BatchMatrixInverse {
    /// Creates a new `BatchMatrixInverse`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `adjoint` attribute.
    pub fn adjoint<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.adjoint = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `BatchMatrixInverse` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("BatchMatrixInverse", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.adjoint {
                nd.set_attr_bool("adjoint", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'BatchMatrixInverse' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<BatchMatrixInverseInst> {
        let op = scope.new_operation("BatchMatrixInverse", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.adjoint {
                builder.set_attr_bool("adjoint", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(BatchMatrixInverseInst { op })
    }
}
impl BatchMatrixInverseInst {
    /// Returns the 'output' Output of this 'BatchMatrixInverse' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'BatchMatrixInverse' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<BatchMatrixInverseInst> for crate::Operation {
    fn from(inst: BatchMatrixInverseInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `BatchMatrixInverse::new().build(input, scope)`.
pub fn batch_matrix_inverse<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    BatchMatrixInverse::new().build(input, scope)
}

/// Builder for the `BatchMatrixSetDiag` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct BatchMatrixSetDiag {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'BatchMatrixSetDiag' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct BatchMatrixSetDiagInst {
    /// An instance of a fully built BatchMatrixSetDiag Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl BatchMatrixSetDiag {
    /// Creates a new `BatchMatrixSetDiag`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `BatchMatrixSetDiag` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        diagonal: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), diagonal.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        diagonal: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("BatchMatrixSetDiag", |nd| {
            nd.add_input(input);
            nd.add_input(diagonal);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'BatchMatrixSetDiag' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        diagonal: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<BatchMatrixSetDiagInst> {
        let op = scope.new_operation("BatchMatrixSetDiag", |builder| {
            builder.add_input(input);
            builder.add_input(diagonal);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(BatchMatrixSetDiagInst { op })
    }
}
impl BatchMatrixSetDiagInst {
    /// Returns the 'output' Output of this 'BatchMatrixSetDiag' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'BatchMatrixSetDiag' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'diagonal' Input of this 'BatchMatrixSetDiag' operation.
    pub fn diagonal(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<BatchMatrixSetDiagInst> for crate::Operation {
    fn from(inst: BatchMatrixSetDiagInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `BatchMatrixSetDiag::new().build(input, diagonal, scope)`.
pub fn batch_matrix_set_diag<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    input: O0,
    diagonal: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    BatchMatrixSetDiag::new().build(input, diagonal, scope)
}

/// Builder for the `BatchMatrixSolve` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct BatchMatrixSolve {
    adjoint: ::std::option::Option<bool>,
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'BatchMatrixSolve' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct BatchMatrixSolveInst {
    /// An instance of a fully built BatchMatrixSolve Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl BatchMatrixSolve {
    /// Creates a new `BatchMatrixSolve`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `adjoint` attribute.
    pub fn adjoint<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.adjoint = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `BatchMatrixSolve` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        matrix: O0,
        rhs: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(matrix.into(), rhs.into(), scope)
    }
    fn build_impl(
        &self,
        matrix: crate::Output,
        rhs: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("BatchMatrixSolve", |nd| {
            nd.add_input(matrix);
            nd.add_input(rhs);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.adjoint {
                nd.set_attr_bool("adjoint", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'BatchMatrixSolve' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        matrix: crate::Output,
        rhs: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<BatchMatrixSolveInst> {
        let op = scope.new_operation("BatchMatrixSolve", |builder| {
            builder.add_input(matrix);
            builder.add_input(rhs);
            if let ::std::option::Option::Some(value) = &self.adjoint {
                builder.set_attr_bool("adjoint", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(BatchMatrixSolveInst { op })
    }
}
impl BatchMatrixSolveInst {
    /// Returns the 'output' Output of this 'BatchMatrixSolve' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'matrix' Input of this 'BatchMatrixSolve' operation.
    pub fn matrix(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'rhs' Input of this 'BatchMatrixSolve' operation.
    pub fn rhs(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<BatchMatrixSolveInst> for crate::Operation {
    fn from(inst: BatchMatrixSolveInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `BatchMatrixSolve::new().build(matrix, rhs, scope)`.
pub fn batch_matrix_solve<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    matrix: O0,
    rhs: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    BatchMatrixSolve::new().build(matrix, rhs, scope)
}

/// Builder for the `BatchMatrixSolveLs` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct BatchMatrixSolveLs {
    T: ::std::option::Option<crate::DataType>,
    fast: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'BatchMatrixSolveLs' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct BatchMatrixSolveLsInst {
    /// An instance of a fully built BatchMatrixSolveLs Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl BatchMatrixSolveLs {
    /// Creates a new `BatchMatrixSolveLs`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `fast` attribute.
    pub fn fast<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.fast = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `BatchMatrixSolveLs` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        matrix: O0,
        rhs: O1,
        l2_regularizer: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(matrix.into(), rhs.into(), l2_regularizer.into(), scope)
    }
    fn build_impl(
        &self,
        matrix: crate::Output,
        rhs: crate::Output,
        l2_regularizer: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("BatchMatrixSolveLs", |nd| {
            nd.add_input(matrix);
            nd.add_input(rhs);
            nd.add_input(l2_regularizer);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.fast {
                nd.set_attr_bool("fast", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'BatchMatrixSolveLs' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        matrix: crate::Output,
        rhs: crate::Output,
        l2_regularizer: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<BatchMatrixSolveLsInst> {
        let op = scope.new_operation("BatchMatrixSolveLs", |builder| {
            builder.add_input(matrix);
            builder.add_input(rhs);
            builder.add_input(l2_regularizer);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.fast {
                builder.set_attr_bool("fast", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(BatchMatrixSolveLsInst { op })
    }
}
impl BatchMatrixSolveLsInst {
    /// Returns the 'output' Output of this 'BatchMatrixSolveLs' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'matrix' Input of this 'BatchMatrixSolveLs' operation.
    pub fn matrix(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'rhs' Input of this 'BatchMatrixSolveLs' operation.
    pub fn rhs(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'l2_regularizer' Input of this 'BatchMatrixSolveLs' operation.
    pub fn l2_regularizer(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<BatchMatrixSolveLsInst> for crate::Operation {
    fn from(inst: BatchMatrixSolveLsInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `BatchMatrixSolveLs::new().build(matrix, rhs, l2_regularizer, scope)`.
pub fn batch_matrix_solve_ls<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    matrix: O0,
    rhs: O1,
    l2_regularizer: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    BatchMatrixSolveLs::new().build(matrix, rhs, l2_regularizer, scope)
}

/// Builder for the `BatchMatrixTriangularSolve` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct BatchMatrixTriangularSolve {
    lower: ::std::option::Option<bool>,
    adjoint: ::std::option::Option<bool>,
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'BatchMatrixTriangularSolve' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct BatchMatrixTriangularSolveInst {
    /// An instance of a fully built BatchMatrixTriangularSolve Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl BatchMatrixTriangularSolve {
    /// Creates a new `BatchMatrixTriangularSolve`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `lower` attribute.
    pub fn lower<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.lower = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `adjoint` attribute.
    pub fn adjoint<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.adjoint = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `BatchMatrixTriangularSolve` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        matrix: O0,
        rhs: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(matrix.into(), rhs.into(), scope)
    }
    fn build_impl(
        &self,
        matrix: crate::Output,
        rhs: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("BatchMatrixTriangularSolve", |nd| {
            nd.add_input(matrix);
            nd.add_input(rhs);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.lower {
                nd.set_attr_bool("lower", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.adjoint {
                nd.set_attr_bool("adjoint", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'BatchMatrixTriangularSolve' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        matrix: crate::Output,
        rhs: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<BatchMatrixTriangularSolveInst> {
        let op = scope.new_operation("BatchMatrixTriangularSolve", |builder| {
            builder.add_input(matrix);
            builder.add_input(rhs);
            if let ::std::option::Option::Some(value) = &self.lower {
                builder.set_attr_bool("lower", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.adjoint {
                builder.set_attr_bool("adjoint", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(BatchMatrixTriangularSolveInst { op })
    }
}
impl BatchMatrixTriangularSolveInst {
    /// Returns the 'output' Output of this 'BatchMatrixTriangularSolve' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'matrix' Input of this 'BatchMatrixTriangularSolve' operation.
    pub fn matrix(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'rhs' Input of this 'BatchMatrixTriangularSolve' operation.
    pub fn rhs(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<BatchMatrixTriangularSolveInst> for crate::Operation {
    fn from(inst: BatchMatrixTriangularSolveInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `BatchMatrixTriangularSolve::new().build(matrix, rhs, scope)`.
pub fn batch_matrix_triangular_solve<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    matrix: O0,
    rhs: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    BatchMatrixTriangularSolve::new().build(matrix, rhs, scope)
}

/// Builder for the `BatchNormWithGlobalNormalization` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct BatchNormWithGlobalNormalization {
    T: ::std::option::Option<crate::DataType>,
    variance_epsilon: ::std::option::Option<f32>,
    scale_after_normalization: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'BatchNormWithGlobalNormalization' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct BatchNormWithGlobalNormalizationInst {
    /// An instance of a fully built BatchNormWithGlobalNormalization Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl BatchNormWithGlobalNormalization {
    /// Creates a new `BatchNormWithGlobalNormalization`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `variance_epsilon` attribute.
    pub fn variance_epsilon<ArgType: ::std::convert::Into<f32>>(mut self, value: ArgType) -> Self {
        self.variance_epsilon = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `scale_after_normalization` attribute.
    pub fn scale_after_normalization<ArgType: ::std::convert::Into<bool>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.scale_after_normalization = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `BatchNormWithGlobalNormalization` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
    >(
        &self,
        t: O0,
        m: O1,
        v: O2,
        beta: O3,
        gamma: O4,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            t.into(),
            m.into(),
            v.into(),
            beta.into(),
            gamma.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        t: crate::Output,
        m: crate::Output,
        v: crate::Output,
        beta: crate::Output,
        gamma: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("BatchNormWithGlobalNormalization", |nd| {
            nd.add_input(t);
            nd.add_input(m);
            nd.add_input(v);
            nd.add_input(beta);
            nd.add_input(gamma);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.variance_epsilon {
                nd.set_attr_float("variance_epsilon", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.scale_after_normalization {
                nd.set_attr_bool("scale_after_normalization", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'BatchNormWithGlobalNormalization' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        t: crate::Output,
        m: crate::Output,
        v: crate::Output,
        beta: crate::Output,
        gamma: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<BatchNormWithGlobalNormalizationInst> {
        let op = scope.new_operation("BatchNormWithGlobalNormalization", |builder| {
            builder.add_input(t);
            builder.add_input(m);
            builder.add_input(v);
            builder.add_input(beta);
            builder.add_input(gamma);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.variance_epsilon {
                builder.set_attr_float("variance_epsilon", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.scale_after_normalization {
                builder.set_attr_bool("scale_after_normalization", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(BatchNormWithGlobalNormalizationInst { op })
    }
}
impl BatchNormWithGlobalNormalizationInst {
    /// Returns the 'result' Output of this 'BatchNormWithGlobalNormalization' operation.
    pub fn result(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 't' Input of this 'BatchNormWithGlobalNormalization' operation.
    pub fn t(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'm' Input of this 'BatchNormWithGlobalNormalization' operation.
    pub fn m(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'v' Input of this 'BatchNormWithGlobalNormalization' operation.
    pub fn v(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'beta' Input of this 'BatchNormWithGlobalNormalization' operation.
    pub fn beta(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'gamma' Input of this 'BatchNormWithGlobalNormalization' operation.
    pub fn gamma(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
}
impl From<BatchNormWithGlobalNormalizationInst> for crate::Operation {
    fn from(inst: BatchNormWithGlobalNormalizationInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `BatchNormWithGlobalNormalization::new().build(t, m, v, beta, gamma, scope)`.
pub fn batch_norm_with_global_normalization<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
>(
    t: O0,
    m: O1,
    v: O2,
    beta: O3,
    gamma: O4,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    BatchNormWithGlobalNormalization::new().build(t, m, v, beta, gamma, scope)
}

/// Builder for the `BatchNormWithGlobalNormalizationGrad` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct BatchNormWithGlobalNormalizationGrad {
    T: ::std::option::Option<crate::DataType>,
    variance_epsilon: ::std::option::Option<f32>,
    scale_after_normalization: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'BatchNormWithGlobalNormalizationGrad' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct BatchNormWithGlobalNormalizationGradInst {
    /// An instance of a fully built BatchNormWithGlobalNormalizationGrad Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl BatchNormWithGlobalNormalizationGrad {
    /// Creates a new `BatchNormWithGlobalNormalizationGrad`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `variance_epsilon` attribute.
    pub fn variance_epsilon<ArgType: ::std::convert::Into<f32>>(mut self, value: ArgType) -> Self {
        self.variance_epsilon = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `scale_after_normalization` attribute.
    pub fn scale_after_normalization<ArgType: ::std::convert::Into<bool>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.scale_after_normalization = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `BatchNormWithGlobalNormalizationGrad` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
    >(
        &self,
        t: O0,
        m: O1,
        v: O2,
        gamma: O3,
        backprop: O4,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            t.into(),
            m.into(),
            v.into(),
            gamma.into(),
            backprop.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        t: crate::Output,
        m: crate::Output,
        v: crate::Output,
        gamma: crate::Output,
        backprop: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("BatchNormWithGlobalNormalizationGrad", |nd| {
            nd.add_input(t);
            nd.add_input(m);
            nd.add_input(v);
            nd.add_input(gamma);
            nd.add_input(backprop);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.variance_epsilon {
                nd.set_attr_float("variance_epsilon", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.scale_after_normalization {
                nd.set_attr_bool("scale_after_normalization", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'BatchNormWithGlobalNormalizationGrad' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        t: crate::Output,
        m: crate::Output,
        v: crate::Output,
        gamma: crate::Output,
        backprop: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<BatchNormWithGlobalNormalizationGradInst> {
        let op = scope.new_operation("BatchNormWithGlobalNormalizationGrad", |builder| {
            builder.add_input(t);
            builder.add_input(m);
            builder.add_input(v);
            builder.add_input(gamma);
            builder.add_input(backprop);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.variance_epsilon {
                builder.set_attr_float("variance_epsilon", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.scale_after_normalization {
                builder.set_attr_bool("scale_after_normalization", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(BatchNormWithGlobalNormalizationGradInst { op })
    }
}
impl BatchNormWithGlobalNormalizationGradInst {
    /// Returns the 'dx' Output of this 'BatchNormWithGlobalNormalizationGrad' operation.
    pub fn dx(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'dm' Output of this 'BatchNormWithGlobalNormalizationGrad' operation.
    pub fn dm(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'dv' Output of this 'BatchNormWithGlobalNormalizationGrad' operation.
    pub fn dv(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns the 'db' Output of this 'BatchNormWithGlobalNormalizationGrad' operation.
    pub fn db(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 3,
        }
    }
    /// Returns the 'dg' Output of this 'BatchNormWithGlobalNormalizationGrad' operation.
    pub fn dg(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 4,
        }
    }
    /// Returns the 't' Input of this 'BatchNormWithGlobalNormalizationGrad' operation.
    pub fn t(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'm' Input of this 'BatchNormWithGlobalNormalizationGrad' operation.
    pub fn m(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'v' Input of this 'BatchNormWithGlobalNormalizationGrad' operation.
    pub fn v(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'gamma' Input of this 'BatchNormWithGlobalNormalizationGrad' operation.
    pub fn gamma(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'backprop' Input of this 'BatchNormWithGlobalNormalizationGrad' operation.
    pub fn backprop(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
}
impl From<BatchNormWithGlobalNormalizationGradInst> for crate::Operation {
    fn from(inst: BatchNormWithGlobalNormalizationGradInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `BatchNormWithGlobalNormalizationGrad::new().build(t, m, v, gamma, backprop, scope)`.
pub fn batch_norm_with_global_normalization_grad<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
>(
    t: O0,
    m: O1,
    v: O2,
    gamma: O3,
    backprop: O4,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    BatchNormWithGlobalNormalizationGrad::new().build(t, m, v, gamma, backprop, scope)
}

/// Builder for the `BatchSelfAdjointEig` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct BatchSelfAdjointEig {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'BatchSelfAdjointEig' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct BatchSelfAdjointEigInst {
    /// An instance of a fully built BatchSelfAdjointEig Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl BatchSelfAdjointEig {
    /// Creates a new `BatchSelfAdjointEig`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `BatchSelfAdjointEig` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("BatchSelfAdjointEig", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'BatchSelfAdjointEig' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<BatchSelfAdjointEigInst> {
        let op = scope.new_operation("BatchSelfAdjointEig", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(BatchSelfAdjointEigInst { op })
    }
}
impl BatchSelfAdjointEigInst {
    /// Returns the 'output' Output of this 'BatchSelfAdjointEig' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'BatchSelfAdjointEig' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<BatchSelfAdjointEigInst> for crate::Operation {
    fn from(inst: BatchSelfAdjointEigInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `BatchSelfAdjointEig::new().build(input, scope)`.
pub fn batch_self_adjoint_eig<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    BatchSelfAdjointEig::new().build(input, scope)
}

/// Builder for the `BatchSelfAdjointEigV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct BatchSelfAdjointEigV2 {
    compute_v: ::std::option::Option<bool>,
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'BatchSelfAdjointEigV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct BatchSelfAdjointEigV2Inst {
    /// An instance of a fully built BatchSelfAdjointEigV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl BatchSelfAdjointEigV2 {
    /// Creates a new `BatchSelfAdjointEigV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `compute_v` attribute.
    pub fn compute_v<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.compute_v = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `BatchSelfAdjointEigV2` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("BatchSelfAdjointEigV2", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.compute_v {
                nd.set_attr_bool("compute_v", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'BatchSelfAdjointEigV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<BatchSelfAdjointEigV2Inst> {
        let op = scope.new_operation("BatchSelfAdjointEigV2", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.compute_v {
                builder.set_attr_bool("compute_v", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(BatchSelfAdjointEigV2Inst { op })
    }
}
impl BatchSelfAdjointEigV2Inst {
    /// Returns the 'e' Output of this 'BatchSelfAdjointEigV2' operation.
    pub fn e(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'v' Output of this 'BatchSelfAdjointEigV2' operation.
    pub fn v(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'input' Input of this 'BatchSelfAdjointEigV2' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<BatchSelfAdjointEigV2Inst> for crate::Operation {
    fn from(inst: BatchSelfAdjointEigV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `BatchSelfAdjointEigV2::new().build(input, scope)`.
pub fn batch_self_adjoint_eig_v2<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    BatchSelfAdjointEigV2::new().build(input, scope)
}

/// Builder for the `BatchSvd` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct BatchSvd {
    compute_uv: ::std::option::Option<bool>,
    full_matrices: ::std::option::Option<bool>,
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'BatchSvd' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct BatchSvdInst {
    /// An instance of a fully built BatchSvd Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl BatchSvd {
    /// Creates a new `BatchSvd`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `compute_uv` attribute.
    pub fn compute_uv<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.compute_uv = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `full_matrices` attribute.
    pub fn full_matrices<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.full_matrices = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `BatchSvd` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("BatchSvd", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.compute_uv {
                nd.set_attr_bool("compute_uv", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.full_matrices {
                nd.set_attr_bool("full_matrices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'BatchSvd' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<BatchSvdInst> {
        let op = scope.new_operation("BatchSvd", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.compute_uv {
                builder.set_attr_bool("compute_uv", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.full_matrices {
                builder.set_attr_bool("full_matrices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(BatchSvdInst { op })
    }
}
impl BatchSvdInst {
    /// Returns the 's' Output of this 'BatchSvd' operation.
    pub fn s(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'u' Output of this 'BatchSvd' operation.
    pub fn u(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'v' Output of this 'BatchSvd' operation.
    pub fn v(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns the 'input' Input of this 'BatchSvd' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<BatchSvdInst> for crate::Operation {
    fn from(inst: BatchSvdInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `BatchSvd::new().build(input, scope)`.
pub fn batch_svd<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    BatchSvd::new().build(input, scope)
}

/// Builder for the `BatchToSpace` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct BatchToSpace {
    T: ::std::option::Option<crate::DataType>,
    block_size: ::std::option::Option<i64>,
    Tidx: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'BatchToSpace' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct BatchToSpaceInst {
    /// An instance of a fully built BatchToSpace Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl BatchToSpace {
    /// Creates a new `BatchToSpace`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `block_size` attribute.
    pub fn block_size<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.block_size = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tidx` attribute.
    pub fn Tidx<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Tidx = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `BatchToSpace` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        crops: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), crops.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        crops: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("BatchToSpace", |nd| {
            nd.add_input(input);
            nd.add_input(crops);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.block_size {
                nd.set_attr_int("block_size", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tidx {
                nd.set_attr_type("Tidx", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'BatchToSpace' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        crops: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<BatchToSpaceInst> {
        let op = scope.new_operation("BatchToSpace", |builder| {
            builder.add_input(input);
            builder.add_input(crops);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.block_size {
                builder.set_attr_int("block_size", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tidx {
                builder.set_attr_type("Tidx", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(BatchToSpaceInst { op })
    }
}
impl BatchToSpaceInst {
    /// Returns the 'output' Output of this 'BatchToSpace' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'BatchToSpace' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'crops' Input of this 'BatchToSpace' operation.
    pub fn crops(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<BatchToSpaceInst> for crate::Operation {
    fn from(inst: BatchToSpaceInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `BatchToSpace::new().build(input, crops, scope)`.
pub fn batch_to_space<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    input: O0,
    crops: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    BatchToSpace::new().build(input, crops, scope)
}

/// Builder for the `BatchToSpaceND` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct BatchToSpaceND {
    T: ::std::option::Option<crate::DataType>,
    Tblock_shape: ::std::option::Option<crate::DataType>,
    Tcrops: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'BatchToSpaceND' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct BatchToSpaceNDInst {
    /// An instance of a fully built BatchToSpaceND Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl BatchToSpaceND {
    /// Creates a new `BatchToSpaceND`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tblock_shape` attribute.
    pub fn Tblock_shape<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tblock_shape = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tcrops` attribute.
    pub fn Tcrops<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tcrops = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `BatchToSpaceND` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        block_shape: O1,
        crops: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), block_shape.into(), crops.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        block_shape: crate::Output,
        crops: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("BatchToSpaceND", |nd| {
            nd.add_input(input);
            nd.add_input(block_shape);
            nd.add_input(crops);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tblock_shape {
                nd.set_attr_type("Tblock_shape", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tcrops {
                nd.set_attr_type("Tcrops", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'BatchToSpaceND' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        block_shape: crate::Output,
        crops: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<BatchToSpaceNDInst> {
        let op = scope.new_operation("BatchToSpaceND", |builder| {
            builder.add_input(input);
            builder.add_input(block_shape);
            builder.add_input(crops);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tblock_shape {
                builder.set_attr_type("Tblock_shape", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tcrops {
                builder.set_attr_type("Tcrops", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(BatchToSpaceNDInst { op })
    }
}
impl BatchToSpaceNDInst {
    /// Returns the 'output' Output of this 'BatchToSpaceND' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'BatchToSpaceND' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'block_shape' Input of this 'BatchToSpaceND' operation.
    pub fn block_shape(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'crops' Input of this 'BatchToSpaceND' operation.
    pub fn crops(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<BatchToSpaceNDInst> for crate::Operation {
    fn from(inst: BatchToSpaceNDInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `BatchToSpaceND::new().build(input, block_shape, crops, scope)`.
pub fn batch_to_space_nd<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    input: O0,
    block_shape: O1,
    crops: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    BatchToSpaceND::new().build(input, block_shape, crops, scope)
}

/// Builder for the `BesselI0` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct BesselI0 {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'BesselI0' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct BesselI0Inst {
    /// An instance of a fully built BesselI0 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl BesselI0 {
    /// Creates a new `BesselI0`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `BesselI0` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        x: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("BesselI0", |nd| {
            nd.add_input(x);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'BesselI0' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<BesselI0Inst> {
        let op = scope.new_operation("BesselI0", |builder| {
            builder.add_input(x);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(BesselI0Inst { op })
    }
}
impl BesselI0Inst {
    /// Returns the 'y' Output of this 'BesselI0' operation.
    pub fn y(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'BesselI0' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<BesselI0Inst> for crate::Operation {
    fn from(inst: BesselI0Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `BesselI0::new().build(x, scope)`.
pub fn bessel_i0<O0: ::std::convert::Into<crate::Output>>(
    x: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    BesselI0::new().build(x, scope)
}

/// Builder for the `BesselI0e` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct BesselI0e {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'BesselI0e' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct BesselI0eInst {
    /// An instance of a fully built BesselI0e Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl BesselI0e {
    /// Creates a new `BesselI0e`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `BesselI0e` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        x: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("BesselI0e", |nd| {
            nd.add_input(x);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'BesselI0e' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<BesselI0eInst> {
        let op = scope.new_operation("BesselI0e", |builder| {
            builder.add_input(x);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(BesselI0eInst { op })
    }
}
impl BesselI0eInst {
    /// Returns the 'y' Output of this 'BesselI0e' operation.
    pub fn y(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'BesselI0e' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<BesselI0eInst> for crate::Operation {
    fn from(inst: BesselI0eInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `BesselI0e::new().build(x, scope)`.
pub fn bessel_i0e<O0: ::std::convert::Into<crate::Output>>(
    x: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    BesselI0e::new().build(x, scope)
}

/// Builder for the `BesselI1` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct BesselI1 {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'BesselI1' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct BesselI1Inst {
    /// An instance of a fully built BesselI1 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl BesselI1 {
    /// Creates a new `BesselI1`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `BesselI1` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        x: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("BesselI1", |nd| {
            nd.add_input(x);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'BesselI1' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<BesselI1Inst> {
        let op = scope.new_operation("BesselI1", |builder| {
            builder.add_input(x);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(BesselI1Inst { op })
    }
}
impl BesselI1Inst {
    /// Returns the 'y' Output of this 'BesselI1' operation.
    pub fn y(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'BesselI1' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<BesselI1Inst> for crate::Operation {
    fn from(inst: BesselI1Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `BesselI1::new().build(x, scope)`.
pub fn bessel_i1<O0: ::std::convert::Into<crate::Output>>(
    x: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    BesselI1::new().build(x, scope)
}

/// Builder for the `BesselI1e` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct BesselI1e {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'BesselI1e' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct BesselI1eInst {
    /// An instance of a fully built BesselI1e Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl BesselI1e {
    /// Creates a new `BesselI1e`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `BesselI1e` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        x: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("BesselI1e", |nd| {
            nd.add_input(x);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'BesselI1e' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<BesselI1eInst> {
        let op = scope.new_operation("BesselI1e", |builder| {
            builder.add_input(x);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(BesselI1eInst { op })
    }
}
impl BesselI1eInst {
    /// Returns the 'y' Output of this 'BesselI1e' operation.
    pub fn y(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'BesselI1e' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<BesselI1eInst> for crate::Operation {
    fn from(inst: BesselI1eInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `BesselI1e::new().build(x, scope)`.
pub fn bessel_i1e<O0: ::std::convert::Into<crate::Output>>(
    x: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    BesselI1e::new().build(x, scope)
}

/// Builder for the `BesselJ0` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct BesselJ0 {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'BesselJ0' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct BesselJ0Inst {
    /// An instance of a fully built BesselJ0 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl BesselJ0 {
    /// Creates a new `BesselJ0`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `BesselJ0` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        x: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("BesselJ0", |nd| {
            nd.add_input(x);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'BesselJ0' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<BesselJ0Inst> {
        let op = scope.new_operation("BesselJ0", |builder| {
            builder.add_input(x);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(BesselJ0Inst { op })
    }
}
impl BesselJ0Inst {
    /// Returns the 'y' Output of this 'BesselJ0' operation.
    pub fn y(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'BesselJ0' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<BesselJ0Inst> for crate::Operation {
    fn from(inst: BesselJ0Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `BesselJ0::new().build(x, scope)`.
pub fn bessel_j0<O0: ::std::convert::Into<crate::Output>>(
    x: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    BesselJ0::new().build(x, scope)
}

/// Builder for the `BesselJ1` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct BesselJ1 {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'BesselJ1' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct BesselJ1Inst {
    /// An instance of a fully built BesselJ1 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl BesselJ1 {
    /// Creates a new `BesselJ1`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `BesselJ1` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        x: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("BesselJ1", |nd| {
            nd.add_input(x);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'BesselJ1' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<BesselJ1Inst> {
        let op = scope.new_operation("BesselJ1", |builder| {
            builder.add_input(x);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(BesselJ1Inst { op })
    }
}
impl BesselJ1Inst {
    /// Returns the 'y' Output of this 'BesselJ1' operation.
    pub fn y(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'BesselJ1' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<BesselJ1Inst> for crate::Operation {
    fn from(inst: BesselJ1Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `BesselJ1::new().build(x, scope)`.
pub fn bessel_j1<O0: ::std::convert::Into<crate::Output>>(
    x: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    BesselJ1::new().build(x, scope)
}

/// Builder for the `BesselK0` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct BesselK0 {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'BesselK0' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct BesselK0Inst {
    /// An instance of a fully built BesselK0 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl BesselK0 {
    /// Creates a new `BesselK0`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `BesselK0` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        x: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("BesselK0", |nd| {
            nd.add_input(x);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'BesselK0' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<BesselK0Inst> {
        let op = scope.new_operation("BesselK0", |builder| {
            builder.add_input(x);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(BesselK0Inst { op })
    }
}
impl BesselK0Inst {
    /// Returns the 'y' Output of this 'BesselK0' operation.
    pub fn y(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'BesselK0' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<BesselK0Inst> for crate::Operation {
    fn from(inst: BesselK0Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `BesselK0::new().build(x, scope)`.
pub fn bessel_k0<O0: ::std::convert::Into<crate::Output>>(
    x: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    BesselK0::new().build(x, scope)
}

/// Builder for the `BesselK0e` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct BesselK0e {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'BesselK0e' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct BesselK0eInst {
    /// An instance of a fully built BesselK0e Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl BesselK0e {
    /// Creates a new `BesselK0e`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `BesselK0e` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        x: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("BesselK0e", |nd| {
            nd.add_input(x);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'BesselK0e' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<BesselK0eInst> {
        let op = scope.new_operation("BesselK0e", |builder| {
            builder.add_input(x);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(BesselK0eInst { op })
    }
}
impl BesselK0eInst {
    /// Returns the 'y' Output of this 'BesselK0e' operation.
    pub fn y(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'BesselK0e' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<BesselK0eInst> for crate::Operation {
    fn from(inst: BesselK0eInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `BesselK0e::new().build(x, scope)`.
pub fn bessel_k0e<O0: ::std::convert::Into<crate::Output>>(
    x: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    BesselK0e::new().build(x, scope)
}

/// Builder for the `BesselK1` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct BesselK1 {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'BesselK1' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct BesselK1Inst {
    /// An instance of a fully built BesselK1 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl BesselK1 {
    /// Creates a new `BesselK1`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `BesselK1` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        x: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("BesselK1", |nd| {
            nd.add_input(x);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'BesselK1' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<BesselK1Inst> {
        let op = scope.new_operation("BesselK1", |builder| {
            builder.add_input(x);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(BesselK1Inst { op })
    }
}
impl BesselK1Inst {
    /// Returns the 'y' Output of this 'BesselK1' operation.
    pub fn y(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'BesselK1' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<BesselK1Inst> for crate::Operation {
    fn from(inst: BesselK1Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `BesselK1::new().build(x, scope)`.
pub fn bessel_k1<O0: ::std::convert::Into<crate::Output>>(
    x: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    BesselK1::new().build(x, scope)
}

/// Builder for the `BesselK1e` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct BesselK1e {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'BesselK1e' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct BesselK1eInst {
    /// An instance of a fully built BesselK1e Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl BesselK1e {
    /// Creates a new `BesselK1e`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `BesselK1e` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        x: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("BesselK1e", |nd| {
            nd.add_input(x);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'BesselK1e' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<BesselK1eInst> {
        let op = scope.new_operation("BesselK1e", |builder| {
            builder.add_input(x);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(BesselK1eInst { op })
    }
}
impl BesselK1eInst {
    /// Returns the 'y' Output of this 'BesselK1e' operation.
    pub fn y(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'BesselK1e' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<BesselK1eInst> for crate::Operation {
    fn from(inst: BesselK1eInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `BesselK1e::new().build(x, scope)`.
pub fn bessel_k1e<O0: ::std::convert::Into<crate::Output>>(
    x: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    BesselK1e::new().build(x, scope)
}

/// Builder for the `BesselY0` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct BesselY0 {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'BesselY0' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct BesselY0Inst {
    /// An instance of a fully built BesselY0 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl BesselY0 {
    /// Creates a new `BesselY0`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `BesselY0` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        x: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("BesselY0", |nd| {
            nd.add_input(x);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'BesselY0' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<BesselY0Inst> {
        let op = scope.new_operation("BesselY0", |builder| {
            builder.add_input(x);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(BesselY0Inst { op })
    }
}
impl BesselY0Inst {
    /// Returns the 'y' Output of this 'BesselY0' operation.
    pub fn y(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'BesselY0' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<BesselY0Inst> for crate::Operation {
    fn from(inst: BesselY0Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `BesselY0::new().build(x, scope)`.
pub fn bessel_y0<O0: ::std::convert::Into<crate::Output>>(
    x: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    BesselY0::new().build(x, scope)
}

/// Builder for the `BesselY1` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct BesselY1 {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'BesselY1' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct BesselY1Inst {
    /// An instance of a fully built BesselY1 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl BesselY1 {
    /// Creates a new `BesselY1`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `BesselY1` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        x: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("BesselY1", |nd| {
            nd.add_input(x);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'BesselY1' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<BesselY1Inst> {
        let op = scope.new_operation("BesselY1", |builder| {
            builder.add_input(x);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(BesselY1Inst { op })
    }
}
impl BesselY1Inst {
    /// Returns the 'y' Output of this 'BesselY1' operation.
    pub fn y(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'BesselY1' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<BesselY1Inst> for crate::Operation {
    fn from(inst: BesselY1Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `BesselY1::new().build(x, scope)`.
pub fn bessel_y1<O0: ::std::convert::Into<crate::Output>>(
    x: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    BesselY1::new().build(x, scope)
}

/// Builder for the `Betainc` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Betainc {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Betainc' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct BetaincInst {
    /// An instance of a fully built Betainc Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Betainc {
    /// Creates a new `Betainc`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Betainc` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        a: O0,
        b: O1,
        x: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(a.into(), b.into(), x.into(), scope)
    }
    fn build_impl(
        &self,
        a: crate::Output,
        b: crate::Output,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Betainc", |nd| {
            nd.add_input(a);
            nd.add_input(b);
            nd.add_input(x);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Betainc' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        a: crate::Output,
        b: crate::Output,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<BetaincInst> {
        let op = scope.new_operation("Betainc", |builder| {
            builder.add_input(a);
            builder.add_input(b);
            builder.add_input(x);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(BetaincInst { op })
    }
}
impl BetaincInst {
    /// Returns the 'z' Output of this 'Betainc' operation.
    pub fn z(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'a' Input of this 'Betainc' operation.
    pub fn a(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'b' Input of this 'Betainc' operation.
    pub fn b(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'x' Input of this 'Betainc' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<BetaincInst> for crate::Operation {
    fn from(inst: BetaincInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Betainc::new().build(a, b, x, scope)`.
pub fn betainc<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    a: O0,
    b: O1,
    x: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Betainc::new().build(a, b, x, scope)
}

/// Builder for the `BiasAdd` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct BiasAdd {
    T: ::std::option::Option<crate::DataType>,
    data_format: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'BiasAdd' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct BiasAddInst {
    /// An instance of a fully built BiasAdd Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl BiasAdd {
    /// Creates a new `BiasAdd`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `data_format` attribute.
    pub fn data_format<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.data_format = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `BiasAdd` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        value: O0,
        bias: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(value.into(), bias.into(), scope)
    }
    fn build_impl(
        &self,
        value: crate::Output,
        bias: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("BiasAdd", |nd| {
            nd.add_input(value);
            nd.add_input(bias);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.data_format {
                nd.set_attr_string("data_format", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'BiasAdd' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        value: crate::Output,
        bias: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<BiasAddInst> {
        let op = scope.new_operation("BiasAdd", |builder| {
            builder.add_input(value);
            builder.add_input(bias);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.data_format {
                builder.set_attr_string("data_format", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(BiasAddInst { op })
    }
}
impl BiasAddInst {
    /// Returns the 'output' Output of this 'BiasAdd' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'value' Input of this 'BiasAdd' operation.
    pub fn value(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'bias' Input of this 'BiasAdd' operation.
    pub fn bias(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<BiasAddInst> for crate::Operation {
    fn from(inst: BiasAddInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `BiasAdd::new().build(value, bias, scope)`.
pub fn bias_add<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    value: O0,
    bias: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    BiasAdd::new().build(value, bias, scope)
}

/// Builder for the `BiasAddGrad` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct BiasAddGrad {
    T: ::std::option::Option<crate::DataType>,
    data_format: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'BiasAddGrad' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct BiasAddGradInst {
    /// An instance of a fully built BiasAddGrad Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl BiasAddGrad {
    /// Creates a new `BiasAddGrad`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `data_format` attribute.
    pub fn data_format<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.data_format = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `BiasAddGrad` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        out_backprop: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(out_backprop.into(), scope)
    }
    fn build_impl(
        &self,
        out_backprop: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("BiasAddGrad", |nd| {
            nd.add_input(out_backprop);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.data_format {
                nd.set_attr_string("data_format", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'BiasAddGrad' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        out_backprop: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<BiasAddGradInst> {
        let op = scope.new_operation("BiasAddGrad", |builder| {
            builder.add_input(out_backprop);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.data_format {
                builder.set_attr_string("data_format", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(BiasAddGradInst { op })
    }
}
impl BiasAddGradInst {
    /// Returns the 'output' Output of this 'BiasAddGrad' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'out_backprop' Input of this 'BiasAddGrad' operation.
    pub fn out_backprop(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<BiasAddGradInst> for crate::Operation {
    fn from(inst: BiasAddGradInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `BiasAddGrad::new().build(out_backprop, scope)`.
pub fn bias_add_grad<O0: ::std::convert::Into<crate::Output>>(
    out_backprop: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    BiasAddGrad::new().build(out_backprop, scope)
}

/// Builder for the `BiasAddV1` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct BiasAddV1 {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'BiasAddV1' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct BiasAddV1Inst {
    /// An instance of a fully built BiasAddV1 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl BiasAddV1 {
    /// Creates a new `BiasAddV1`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `BiasAddV1` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        value: O0,
        bias: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(value.into(), bias.into(), scope)
    }
    fn build_impl(
        &self,
        value: crate::Output,
        bias: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("BiasAddV1", |nd| {
            nd.add_input(value);
            nd.add_input(bias);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'BiasAddV1' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        value: crate::Output,
        bias: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<BiasAddV1Inst> {
        let op = scope.new_operation("BiasAddV1", |builder| {
            builder.add_input(value);
            builder.add_input(bias);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(BiasAddV1Inst { op })
    }
}
impl BiasAddV1Inst {
    /// Returns the 'output' Output of this 'BiasAddV1' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'value' Input of this 'BiasAddV1' operation.
    pub fn value(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'bias' Input of this 'BiasAddV1' operation.
    pub fn bias(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<BiasAddV1Inst> for crate::Operation {
    fn from(inst: BiasAddV1Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `BiasAddV1::new().build(value, bias, scope)`.
pub fn bias_add_v1<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    value: O0,
    bias: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    BiasAddV1::new().build(value, bias, scope)
}

/// Builder for the `Bincount` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Bincount {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Bincount' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct BincountInst {
    /// An instance of a fully built Bincount Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Bincount {
    /// Creates a new `Bincount`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Bincount` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        arr: O0,
        size: O1,
        weights: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(arr.into(), size.into(), weights.into(), scope)
    }
    fn build_impl(
        &self,
        arr: crate::Output,
        size: crate::Output,
        weights: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Bincount", |nd| {
            nd.add_input(arr);
            nd.add_input(size);
            nd.add_input(weights);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Bincount' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        arr: crate::Output,
        size: crate::Output,
        weights: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<BincountInst> {
        let op = scope.new_operation("Bincount", |builder| {
            builder.add_input(arr);
            builder.add_input(size);
            builder.add_input(weights);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(BincountInst { op })
    }
}
impl BincountInst {
    /// Returns the 'bins' Output of this 'Bincount' operation.
    pub fn bins(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'arr' Input of this 'Bincount' operation.
    pub fn arr(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'size' Input of this 'Bincount' operation.
    pub fn size(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'weights' Input of this 'Bincount' operation.
    pub fn weights(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<BincountInst> for crate::Operation {
    fn from(inst: BincountInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Bincount::new().build(arr, size, weights, scope)`.
pub fn bincount<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    arr: O0,
    size: O1,
    weights: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Bincount::new().build(arr, size, weights, scope)
}

/// Builder for the `Bitcast` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Bitcast {
    T: ::std::option::Option<crate::DataType>,
    type_: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Bitcast' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct BitcastInst {
    /// An instance of a fully built Bitcast Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Bitcast {
    /// Creates a new `Bitcast`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `type` attribute.
    pub fn type_<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.type_ = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Bitcast` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Bitcast", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.type_ {
                nd.set_attr_type("type", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Bitcast' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<BitcastInst> {
        let op = scope.new_operation("Bitcast", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.type_ {
                builder.set_attr_type("type", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(BitcastInst { op })
    }
}
impl BitcastInst {
    /// Returns the 'output' Output of this 'Bitcast' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'Bitcast' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<BitcastInst> for crate::Operation {
    fn from(inst: BitcastInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Bitcast::new().build(input, scope)`.
pub fn bitcast<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Bitcast::new().build(input, scope)
}

/// Builder for the `BitwiseAnd` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct BitwiseAnd {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'BitwiseAnd' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct BitwiseAndInst {
    /// An instance of a fully built BitwiseAnd Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl BitwiseAnd {
    /// Creates a new `BitwiseAnd`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `BitwiseAnd` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        x: O0,
        y: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), y.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        y: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("BitwiseAnd", |nd| {
            nd.add_input(x);
            nd.add_input(y);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'BitwiseAnd' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        y: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<BitwiseAndInst> {
        let op = scope.new_operation("BitwiseAnd", |builder| {
            builder.add_input(x);
            builder.add_input(y);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(BitwiseAndInst { op })
    }
}
impl BitwiseAndInst {
    /// Returns the 'z' Output of this 'BitwiseAnd' operation.
    pub fn z(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'BitwiseAnd' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'y' Input of this 'BitwiseAnd' operation.
    pub fn y(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<BitwiseAndInst> for crate::Operation {
    fn from(inst: BitwiseAndInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `BitwiseAnd::new().build(x, y, scope)`.
pub fn bitwise_and<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    x: O0,
    y: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    BitwiseAnd::new().build(x, y, scope)
}

/// Builder for the `BitwiseOr` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct BitwiseOr {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'BitwiseOr' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct BitwiseOrInst {
    /// An instance of a fully built BitwiseOr Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl BitwiseOr {
    /// Creates a new `BitwiseOr`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `BitwiseOr` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        x: O0,
        y: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), y.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        y: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("BitwiseOr", |nd| {
            nd.add_input(x);
            nd.add_input(y);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'BitwiseOr' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        y: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<BitwiseOrInst> {
        let op = scope.new_operation("BitwiseOr", |builder| {
            builder.add_input(x);
            builder.add_input(y);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(BitwiseOrInst { op })
    }
}
impl BitwiseOrInst {
    /// Returns the 'z' Output of this 'BitwiseOr' operation.
    pub fn z(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'BitwiseOr' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'y' Input of this 'BitwiseOr' operation.
    pub fn y(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<BitwiseOrInst> for crate::Operation {
    fn from(inst: BitwiseOrInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `BitwiseOr::new().build(x, y, scope)`.
pub fn bitwise_or<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    x: O0,
    y: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    BitwiseOr::new().build(x, y, scope)
}

/// Builder for the `BitwiseXor` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct BitwiseXor {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'BitwiseXor' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct BitwiseXorInst {
    /// An instance of a fully built BitwiseXor Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl BitwiseXor {
    /// Creates a new `BitwiseXor`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `BitwiseXor` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        x: O0,
        y: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), y.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        y: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("BitwiseXor", |nd| {
            nd.add_input(x);
            nd.add_input(y);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'BitwiseXor' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        y: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<BitwiseXorInst> {
        let op = scope.new_operation("BitwiseXor", |builder| {
            builder.add_input(x);
            builder.add_input(y);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(BitwiseXorInst { op })
    }
}
impl BitwiseXorInst {
    /// Returns the 'z' Output of this 'BitwiseXor' operation.
    pub fn z(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'BitwiseXor' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'y' Input of this 'BitwiseXor' operation.
    pub fn y(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<BitwiseXorInst> for crate::Operation {
    fn from(inst: BitwiseXorInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `BitwiseXor::new().build(x, y, scope)`.
pub fn bitwise_xor<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    x: O0,
    y: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    BitwiseXor::new().build(x, y, scope)
}

/// Builder for the `BlockLSTM` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct BlockLSTM {
    forget_bias: ::std::option::Option<f32>,
    cell_clip: ::std::option::Option<f32>,
    use_peephole: ::std::option::Option<bool>,
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'BlockLSTM' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct BlockLSTMInst {
    /// An instance of a fully built BlockLSTM Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl BlockLSTM {
    /// Creates a new `BlockLSTM`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `forget_bias` attribute.
    pub fn forget_bias<ArgType: ::std::convert::Into<f32>>(mut self, value: ArgType) -> Self {
        self.forget_bias = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `cell_clip` attribute.
    pub fn cell_clip<ArgType: ::std::convert::Into<f32>>(mut self, value: ArgType) -> Self {
        self.cell_clip = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_peephole` attribute.
    pub fn use_peephole<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.use_peephole = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `BlockLSTM` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
        O6: ::std::convert::Into<crate::Output>,
        O7: ::std::convert::Into<crate::Output>,
        O8: ::std::convert::Into<crate::Output>,
    >(
        &self,
        seq_len_max: O0,
        x: O1,
        cs_prev: O2,
        h_prev: O3,
        w: O4,
        wci: O5,
        wcf: O6,
        wco: O7,
        b: O8,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            seq_len_max.into(),
            x.into(),
            cs_prev.into(),
            h_prev.into(),
            w.into(),
            wci.into(),
            wcf.into(),
            wco.into(),
            b.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        seq_len_max: crate::Output,
        x: crate::Output,
        cs_prev: crate::Output,
        h_prev: crate::Output,
        w: crate::Output,
        wci: crate::Output,
        wcf: crate::Output,
        wco: crate::Output,
        b: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("BlockLSTM", |nd| {
            nd.add_input(seq_len_max);
            nd.add_input(x);
            nd.add_input(cs_prev);
            nd.add_input(h_prev);
            nd.add_input(w);
            nd.add_input(wci);
            nd.add_input(wcf);
            nd.add_input(wco);
            nd.add_input(b);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.forget_bias {
                nd.set_attr_float("forget_bias", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.cell_clip {
                nd.set_attr_float("cell_clip", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_peephole {
                nd.set_attr_bool("use_peephole", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'BlockLSTM' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        seq_len_max: crate::Output,
        x: crate::Output,
        cs_prev: crate::Output,
        h_prev: crate::Output,
        w: crate::Output,
        wci: crate::Output,
        wcf: crate::Output,
        wco: crate::Output,
        b: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<BlockLSTMInst> {
        let op = scope.new_operation("BlockLSTM", |builder| {
            builder.add_input(seq_len_max);
            builder.add_input(x);
            builder.add_input(cs_prev);
            builder.add_input(h_prev);
            builder.add_input(w);
            builder.add_input(wci);
            builder.add_input(wcf);
            builder.add_input(wco);
            builder.add_input(b);
            if let ::std::option::Option::Some(value) = &self.forget_bias {
                builder.set_attr_float("forget_bias", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.cell_clip {
                builder.set_attr_float("cell_clip", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_peephole {
                builder.set_attr_bool("use_peephole", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(BlockLSTMInst { op })
    }
}
impl BlockLSTMInst {
    /// Returns the 'i' Output of this 'BlockLSTM' operation.
    pub fn i(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'cs' Output of this 'BlockLSTM' operation.
    pub fn cs(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'f' Output of this 'BlockLSTM' operation.
    pub fn f(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns the 'o' Output of this 'BlockLSTM' operation.
    pub fn o(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 3,
        }
    }
    /// Returns the 'ci' Output of this 'BlockLSTM' operation.
    pub fn ci(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 4,
        }
    }
    /// Returns the 'co' Output of this 'BlockLSTM' operation.
    pub fn co(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 5,
        }
    }
    /// Returns the 'h' Output of this 'BlockLSTM' operation.
    pub fn h(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 6,
        }
    }
    /// Returns the 'seq_len_max' Input of this 'BlockLSTM' operation.
    pub fn seq_len_max(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'BlockLSTM' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'cs_prev' Input of this 'BlockLSTM' operation.
    pub fn cs_prev(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'h_prev' Input of this 'BlockLSTM' operation.
    pub fn h_prev(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'w' Input of this 'BlockLSTM' operation.
    pub fn w(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
    /// Returns the 'wci' Input of this 'BlockLSTM' operation.
    pub fn wci(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 5,
        }
    }
    /// Returns the 'wcf' Input of this 'BlockLSTM' operation.
    pub fn wcf(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 6,
        }
    }
    /// Returns the 'wco' Input of this 'BlockLSTM' operation.
    pub fn wco(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 7,
        }
    }
    /// Returns the 'b' Input of this 'BlockLSTM' operation.
    pub fn b(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 8,
        }
    }
}
impl From<BlockLSTMInst> for crate::Operation {
    fn from(inst: BlockLSTMInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `BlockLSTM::new().build(seq_len_max, x, cs_prev, h_prev, w, wci, wcf, wco, b, scope)`.
pub fn block_lstm<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
    O6: ::std::convert::Into<crate::Output>,
    O7: ::std::convert::Into<crate::Output>,
    O8: ::std::convert::Into<crate::Output>,
>(
    seq_len_max: O0,
    x: O1,
    cs_prev: O2,
    h_prev: O3,
    w: O4,
    wci: O5,
    wcf: O6,
    wco: O7,
    b: O8,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    BlockLSTM::new().build(seq_len_max, x, cs_prev, h_prev, w, wci, wcf, wco, b, scope)
}

/// Builder for the `BlockLSTMGrad` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct BlockLSTMGrad {
    use_peephole: ::std::option::Option<bool>,
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'BlockLSTMGrad' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct BlockLSTMGradInst {
    /// An instance of a fully built BlockLSTMGrad Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl BlockLSTMGrad {
    /// Creates a new `BlockLSTMGrad`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `use_peephole` attribute.
    pub fn use_peephole<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.use_peephole = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `BlockLSTMGrad` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
        O6: ::std::convert::Into<crate::Output>,
        O7: ::std::convert::Into<crate::Output>,
        O8: ::std::convert::Into<crate::Output>,
        O9: ::std::convert::Into<crate::Output>,
        O10: ::std::convert::Into<crate::Output>,
        O11: ::std::convert::Into<crate::Output>,
        O12: ::std::convert::Into<crate::Output>,
        O13: ::std::convert::Into<crate::Output>,
        O14: ::std::convert::Into<crate::Output>,
        O15: ::std::convert::Into<crate::Output>,
        O16: ::std::convert::Into<crate::Output>,
        O17: ::std::convert::Into<crate::Output>,
    >(
        &self,
        seq_len_max: O0,
        x: O1,
        cs_prev: O2,
        h_prev: O3,
        w: O4,
        wci: O5,
        wcf: O6,
        wco: O7,
        b: O8,
        i: O9,
        cs: O10,
        f: O11,
        o: O12,
        ci: O13,
        co: O14,
        h: O15,
        cs_grad: O16,
        h_grad: O17,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            seq_len_max.into(),
            x.into(),
            cs_prev.into(),
            h_prev.into(),
            w.into(),
            wci.into(),
            wcf.into(),
            wco.into(),
            b.into(),
            i.into(),
            cs.into(),
            f.into(),
            o.into(),
            ci.into(),
            co.into(),
            h.into(),
            cs_grad.into(),
            h_grad.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        seq_len_max: crate::Output,
        x: crate::Output,
        cs_prev: crate::Output,
        h_prev: crate::Output,
        w: crate::Output,
        wci: crate::Output,
        wcf: crate::Output,
        wco: crate::Output,
        b: crate::Output,
        i: crate::Output,
        cs: crate::Output,
        f: crate::Output,
        o: crate::Output,
        ci: crate::Output,
        co: crate::Output,
        h: crate::Output,
        cs_grad: crate::Output,
        h_grad: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("BlockLSTMGrad", |nd| {
            nd.add_input(seq_len_max);
            nd.add_input(x);
            nd.add_input(cs_prev);
            nd.add_input(h_prev);
            nd.add_input(w);
            nd.add_input(wci);
            nd.add_input(wcf);
            nd.add_input(wco);
            nd.add_input(b);
            nd.add_input(i);
            nd.add_input(cs);
            nd.add_input(f);
            nd.add_input(o);
            nd.add_input(ci);
            nd.add_input(co);
            nd.add_input(h);
            nd.add_input(cs_grad);
            nd.add_input(h_grad);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.use_peephole {
                nd.set_attr_bool("use_peephole", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'BlockLSTMGrad' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        seq_len_max: crate::Output,
        x: crate::Output,
        cs_prev: crate::Output,
        h_prev: crate::Output,
        w: crate::Output,
        wci: crate::Output,
        wcf: crate::Output,
        wco: crate::Output,
        b: crate::Output,
        i: crate::Output,
        cs: crate::Output,
        f: crate::Output,
        o: crate::Output,
        ci: crate::Output,
        co: crate::Output,
        h: crate::Output,
        cs_grad: crate::Output,
        h_grad: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<BlockLSTMGradInst> {
        let op = scope.new_operation("BlockLSTMGrad", |builder| {
            builder.add_input(seq_len_max);
            builder.add_input(x);
            builder.add_input(cs_prev);
            builder.add_input(h_prev);
            builder.add_input(w);
            builder.add_input(wci);
            builder.add_input(wcf);
            builder.add_input(wco);
            builder.add_input(b);
            builder.add_input(i);
            builder.add_input(cs);
            builder.add_input(f);
            builder.add_input(o);
            builder.add_input(ci);
            builder.add_input(co);
            builder.add_input(h);
            builder.add_input(cs_grad);
            builder.add_input(h_grad);
            if let ::std::option::Option::Some(value) = &self.use_peephole {
                builder.set_attr_bool("use_peephole", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(BlockLSTMGradInst { op })
    }
}
impl BlockLSTMGradInst {
    /// Returns the 'x_grad' Output of this 'BlockLSTMGrad' operation.
    pub fn x_grad(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'cs_prev_grad' Output of this 'BlockLSTMGrad' operation.
    pub fn cs_prev_grad(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'h_prev_grad' Output of this 'BlockLSTMGrad' operation.
    pub fn h_prev_grad(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns the 'w_grad' Output of this 'BlockLSTMGrad' operation.
    pub fn w_grad(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 3,
        }
    }
    /// Returns the 'wci_grad' Output of this 'BlockLSTMGrad' operation.
    pub fn wci_grad(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 4,
        }
    }
    /// Returns the 'wcf_grad' Output of this 'BlockLSTMGrad' operation.
    pub fn wcf_grad(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 5,
        }
    }
    /// Returns the 'wco_grad' Output of this 'BlockLSTMGrad' operation.
    pub fn wco_grad(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 6,
        }
    }
    /// Returns the 'b_grad' Output of this 'BlockLSTMGrad' operation.
    pub fn b_grad(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 7,
        }
    }
    /// Returns the 'seq_len_max' Input of this 'BlockLSTMGrad' operation.
    pub fn seq_len_max(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'BlockLSTMGrad' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'cs_prev' Input of this 'BlockLSTMGrad' operation.
    pub fn cs_prev(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'h_prev' Input of this 'BlockLSTMGrad' operation.
    pub fn h_prev(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'w' Input of this 'BlockLSTMGrad' operation.
    pub fn w(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
    /// Returns the 'wci' Input of this 'BlockLSTMGrad' operation.
    pub fn wci(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 5,
        }
    }
    /// Returns the 'wcf' Input of this 'BlockLSTMGrad' operation.
    pub fn wcf(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 6,
        }
    }
    /// Returns the 'wco' Input of this 'BlockLSTMGrad' operation.
    pub fn wco(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 7,
        }
    }
    /// Returns the 'b' Input of this 'BlockLSTMGrad' operation.
    pub fn b(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 8,
        }
    }
    /// Returns the 'i' Input of this 'BlockLSTMGrad' operation.
    pub fn i(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 9,
        }
    }
    /// Returns the 'cs' Input of this 'BlockLSTMGrad' operation.
    pub fn cs(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 10,
        }
    }
    /// Returns the 'f' Input of this 'BlockLSTMGrad' operation.
    pub fn f(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 11,
        }
    }
    /// Returns the 'o' Input of this 'BlockLSTMGrad' operation.
    pub fn o(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 12,
        }
    }
    /// Returns the 'ci' Input of this 'BlockLSTMGrad' operation.
    pub fn ci(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 13,
        }
    }
    /// Returns the 'co' Input of this 'BlockLSTMGrad' operation.
    pub fn co(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 14,
        }
    }
    /// Returns the 'h' Input of this 'BlockLSTMGrad' operation.
    pub fn h(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 15,
        }
    }
    /// Returns the 'cs_grad' Input of this 'BlockLSTMGrad' operation.
    pub fn cs_grad(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 16,
        }
    }
    /// Returns the 'h_grad' Input of this 'BlockLSTMGrad' operation.
    pub fn h_grad(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 17,
        }
    }
}
impl From<BlockLSTMGradInst> for crate::Operation {
    fn from(inst: BlockLSTMGradInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `BlockLSTMGrad::new().build(seq_len_max, x, cs_prev, h_prev, w, wci, wcf, wco, b, i, cs, f, o, ci, co, h, cs_grad, h_grad, scope)`.
pub fn block_lstmgrad<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
    O6: ::std::convert::Into<crate::Output>,
    O7: ::std::convert::Into<crate::Output>,
    O8: ::std::convert::Into<crate::Output>,
    O9: ::std::convert::Into<crate::Output>,
    O10: ::std::convert::Into<crate::Output>,
    O11: ::std::convert::Into<crate::Output>,
    O12: ::std::convert::Into<crate::Output>,
    O13: ::std::convert::Into<crate::Output>,
    O14: ::std::convert::Into<crate::Output>,
    O15: ::std::convert::Into<crate::Output>,
    O16: ::std::convert::Into<crate::Output>,
    O17: ::std::convert::Into<crate::Output>,
>(
    seq_len_max: O0,
    x: O1,
    cs_prev: O2,
    h_prev: O3,
    w: O4,
    wci: O5,
    wcf: O6,
    wco: O7,
    b: O8,
    i: O9,
    cs: O10,
    f: O11,
    o: O12,
    ci: O13,
    co: O14,
    h: O15,
    cs_grad: O16,
    h_grad: O17,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    BlockLSTMGrad::new().build(
        seq_len_max,
        x,
        cs_prev,
        h_prev,
        w,
        wci,
        wcf,
        wco,
        b,
        i,
        cs,
        f,
        o,
        ci,
        co,
        h,
        cs_grad,
        h_grad,
        scope,
    )
}

/// Builder for the `BlockLSTMGradV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct BlockLSTMGradV2 {
    use_peephole: ::std::option::Option<bool>,
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'BlockLSTMGradV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct BlockLSTMGradV2Inst {
    /// An instance of a fully built BlockLSTMGradV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl BlockLSTMGradV2 {
    /// Creates a new `BlockLSTMGradV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `use_peephole` attribute.
    pub fn use_peephole<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.use_peephole = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `BlockLSTMGradV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
        O6: ::std::convert::Into<crate::Output>,
        O7: ::std::convert::Into<crate::Output>,
        O8: ::std::convert::Into<crate::Output>,
        O9: ::std::convert::Into<crate::Output>,
        O10: ::std::convert::Into<crate::Output>,
        O11: ::std::convert::Into<crate::Output>,
        O12: ::std::convert::Into<crate::Output>,
        O13: ::std::convert::Into<crate::Output>,
        O14: ::std::convert::Into<crate::Output>,
        O15: ::std::convert::Into<crate::Output>,
        O16: ::std::convert::Into<crate::Output>,
        O17: ::std::convert::Into<crate::Output>,
    >(
        &self,
        seq_len_max: O0,
        x: O1,
        cs_prev: O2,
        h_prev: O3,
        w: O4,
        wci: O5,
        wcf: O6,
        wco: O7,
        b: O8,
        i: O9,
        cs: O10,
        f: O11,
        o: O12,
        ci: O13,
        co: O14,
        h: O15,
        cs_grad: O16,
        h_grad: O17,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            seq_len_max.into(),
            x.into(),
            cs_prev.into(),
            h_prev.into(),
            w.into(),
            wci.into(),
            wcf.into(),
            wco.into(),
            b.into(),
            i.into(),
            cs.into(),
            f.into(),
            o.into(),
            ci.into(),
            co.into(),
            h.into(),
            cs_grad.into(),
            h_grad.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        seq_len_max: crate::Output,
        x: crate::Output,
        cs_prev: crate::Output,
        h_prev: crate::Output,
        w: crate::Output,
        wci: crate::Output,
        wcf: crate::Output,
        wco: crate::Output,
        b: crate::Output,
        i: crate::Output,
        cs: crate::Output,
        f: crate::Output,
        o: crate::Output,
        ci: crate::Output,
        co: crate::Output,
        h: crate::Output,
        cs_grad: crate::Output,
        h_grad: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("BlockLSTMGradV2", |nd| {
            nd.add_input(seq_len_max);
            nd.add_input(x);
            nd.add_input(cs_prev);
            nd.add_input(h_prev);
            nd.add_input(w);
            nd.add_input(wci);
            nd.add_input(wcf);
            nd.add_input(wco);
            nd.add_input(b);
            nd.add_input(i);
            nd.add_input(cs);
            nd.add_input(f);
            nd.add_input(o);
            nd.add_input(ci);
            nd.add_input(co);
            nd.add_input(h);
            nd.add_input(cs_grad);
            nd.add_input(h_grad);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.use_peephole {
                nd.set_attr_bool("use_peephole", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'BlockLSTMGradV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        seq_len_max: crate::Output,
        x: crate::Output,
        cs_prev: crate::Output,
        h_prev: crate::Output,
        w: crate::Output,
        wci: crate::Output,
        wcf: crate::Output,
        wco: crate::Output,
        b: crate::Output,
        i: crate::Output,
        cs: crate::Output,
        f: crate::Output,
        o: crate::Output,
        ci: crate::Output,
        co: crate::Output,
        h: crate::Output,
        cs_grad: crate::Output,
        h_grad: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<BlockLSTMGradV2Inst> {
        let op = scope.new_operation("BlockLSTMGradV2", |builder| {
            builder.add_input(seq_len_max);
            builder.add_input(x);
            builder.add_input(cs_prev);
            builder.add_input(h_prev);
            builder.add_input(w);
            builder.add_input(wci);
            builder.add_input(wcf);
            builder.add_input(wco);
            builder.add_input(b);
            builder.add_input(i);
            builder.add_input(cs);
            builder.add_input(f);
            builder.add_input(o);
            builder.add_input(ci);
            builder.add_input(co);
            builder.add_input(h);
            builder.add_input(cs_grad);
            builder.add_input(h_grad);
            if let ::std::option::Option::Some(value) = &self.use_peephole {
                builder.set_attr_bool("use_peephole", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(BlockLSTMGradV2Inst { op })
    }
}
impl BlockLSTMGradV2Inst {
    /// Returns the 'x_grad' Output of this 'BlockLSTMGradV2' operation.
    pub fn x_grad(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'cs_prev_grad' Output of this 'BlockLSTMGradV2' operation.
    pub fn cs_prev_grad(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'h_prev_grad' Output of this 'BlockLSTMGradV2' operation.
    pub fn h_prev_grad(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns the 'w_grad' Output of this 'BlockLSTMGradV2' operation.
    pub fn w_grad(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 3,
        }
    }
    /// Returns the 'wci_grad' Output of this 'BlockLSTMGradV2' operation.
    pub fn wci_grad(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 4,
        }
    }
    /// Returns the 'wcf_grad' Output of this 'BlockLSTMGradV2' operation.
    pub fn wcf_grad(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 5,
        }
    }
    /// Returns the 'wco_grad' Output of this 'BlockLSTMGradV2' operation.
    pub fn wco_grad(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 6,
        }
    }
    /// Returns the 'b_grad' Output of this 'BlockLSTMGradV2' operation.
    pub fn b_grad(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 7,
        }
    }
    /// Returns the 'seq_len_max' Input of this 'BlockLSTMGradV2' operation.
    pub fn seq_len_max(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'BlockLSTMGradV2' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'cs_prev' Input of this 'BlockLSTMGradV2' operation.
    pub fn cs_prev(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'h_prev' Input of this 'BlockLSTMGradV2' operation.
    pub fn h_prev(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'w' Input of this 'BlockLSTMGradV2' operation.
    pub fn w(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
    /// Returns the 'wci' Input of this 'BlockLSTMGradV2' operation.
    pub fn wci(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 5,
        }
    }
    /// Returns the 'wcf' Input of this 'BlockLSTMGradV2' operation.
    pub fn wcf(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 6,
        }
    }
    /// Returns the 'wco' Input of this 'BlockLSTMGradV2' operation.
    pub fn wco(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 7,
        }
    }
    /// Returns the 'b' Input of this 'BlockLSTMGradV2' operation.
    pub fn b(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 8,
        }
    }
    /// Returns the 'i' Input of this 'BlockLSTMGradV2' operation.
    pub fn i(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 9,
        }
    }
    /// Returns the 'cs' Input of this 'BlockLSTMGradV2' operation.
    pub fn cs(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 10,
        }
    }
    /// Returns the 'f' Input of this 'BlockLSTMGradV2' operation.
    pub fn f(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 11,
        }
    }
    /// Returns the 'o' Input of this 'BlockLSTMGradV2' operation.
    pub fn o(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 12,
        }
    }
    /// Returns the 'ci' Input of this 'BlockLSTMGradV2' operation.
    pub fn ci(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 13,
        }
    }
    /// Returns the 'co' Input of this 'BlockLSTMGradV2' operation.
    pub fn co(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 14,
        }
    }
    /// Returns the 'h' Input of this 'BlockLSTMGradV2' operation.
    pub fn h(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 15,
        }
    }
    /// Returns the 'cs_grad' Input of this 'BlockLSTMGradV2' operation.
    pub fn cs_grad(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 16,
        }
    }
    /// Returns the 'h_grad' Input of this 'BlockLSTMGradV2' operation.
    pub fn h_grad(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 17,
        }
    }
}
impl From<BlockLSTMGradV2Inst> for crate::Operation {
    fn from(inst: BlockLSTMGradV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `BlockLSTMGradV2::new().build(seq_len_max, x, cs_prev, h_prev, w, wci, wcf, wco, b, i, cs, f, o, ci, co, h, cs_grad, h_grad, scope)`.
pub fn block_lstmgrad_v2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
    O6: ::std::convert::Into<crate::Output>,
    O7: ::std::convert::Into<crate::Output>,
    O8: ::std::convert::Into<crate::Output>,
    O9: ::std::convert::Into<crate::Output>,
    O10: ::std::convert::Into<crate::Output>,
    O11: ::std::convert::Into<crate::Output>,
    O12: ::std::convert::Into<crate::Output>,
    O13: ::std::convert::Into<crate::Output>,
    O14: ::std::convert::Into<crate::Output>,
    O15: ::std::convert::Into<crate::Output>,
    O16: ::std::convert::Into<crate::Output>,
    O17: ::std::convert::Into<crate::Output>,
>(
    seq_len_max: O0,
    x: O1,
    cs_prev: O2,
    h_prev: O3,
    w: O4,
    wci: O5,
    wcf: O6,
    wco: O7,
    b: O8,
    i: O9,
    cs: O10,
    f: O11,
    o: O12,
    ci: O13,
    co: O14,
    h: O15,
    cs_grad: O16,
    h_grad: O17,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    BlockLSTMGradV2::new().build(
        seq_len_max,
        x,
        cs_prev,
        h_prev,
        w,
        wci,
        wcf,
        wco,
        b,
        i,
        cs,
        f,
        o,
        ci,
        co,
        h,
        cs_grad,
        h_grad,
        scope,
    )
}

/// Builder for the `BlockLSTMV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct BlockLSTMV2 {
    cell_clip: ::std::option::Option<f32>,
    use_peephole: ::std::option::Option<bool>,
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'BlockLSTMV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct BlockLSTMV2Inst {
    /// An instance of a fully built BlockLSTMV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl BlockLSTMV2 {
    /// Creates a new `BlockLSTMV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `cell_clip` attribute.
    pub fn cell_clip<ArgType: ::std::convert::Into<f32>>(mut self, value: ArgType) -> Self {
        self.cell_clip = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_peephole` attribute.
    pub fn use_peephole<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.use_peephole = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `BlockLSTMV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
        O6: ::std::convert::Into<crate::Output>,
        O7: ::std::convert::Into<crate::Output>,
        O8: ::std::convert::Into<crate::Output>,
    >(
        &self,
        seq_len_max: O0,
        x: O1,
        cs_prev: O2,
        h_prev: O3,
        w: O4,
        wci: O5,
        wcf: O6,
        wco: O7,
        b: O8,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            seq_len_max.into(),
            x.into(),
            cs_prev.into(),
            h_prev.into(),
            w.into(),
            wci.into(),
            wcf.into(),
            wco.into(),
            b.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        seq_len_max: crate::Output,
        x: crate::Output,
        cs_prev: crate::Output,
        h_prev: crate::Output,
        w: crate::Output,
        wci: crate::Output,
        wcf: crate::Output,
        wco: crate::Output,
        b: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("BlockLSTMV2", |nd| {
            nd.add_input(seq_len_max);
            nd.add_input(x);
            nd.add_input(cs_prev);
            nd.add_input(h_prev);
            nd.add_input(w);
            nd.add_input(wci);
            nd.add_input(wcf);
            nd.add_input(wco);
            nd.add_input(b);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.cell_clip {
                nd.set_attr_float("cell_clip", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_peephole {
                nd.set_attr_bool("use_peephole", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'BlockLSTMV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        seq_len_max: crate::Output,
        x: crate::Output,
        cs_prev: crate::Output,
        h_prev: crate::Output,
        w: crate::Output,
        wci: crate::Output,
        wcf: crate::Output,
        wco: crate::Output,
        b: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<BlockLSTMV2Inst> {
        let op = scope.new_operation("BlockLSTMV2", |builder| {
            builder.add_input(seq_len_max);
            builder.add_input(x);
            builder.add_input(cs_prev);
            builder.add_input(h_prev);
            builder.add_input(w);
            builder.add_input(wci);
            builder.add_input(wcf);
            builder.add_input(wco);
            builder.add_input(b);
            if let ::std::option::Option::Some(value) = &self.cell_clip {
                builder.set_attr_float("cell_clip", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_peephole {
                builder.set_attr_bool("use_peephole", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(BlockLSTMV2Inst { op })
    }
}
impl BlockLSTMV2Inst {
    /// Returns the 'i' Output of this 'BlockLSTMV2' operation.
    pub fn i(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'cs' Output of this 'BlockLSTMV2' operation.
    pub fn cs(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'f' Output of this 'BlockLSTMV2' operation.
    pub fn f(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns the 'o' Output of this 'BlockLSTMV2' operation.
    pub fn o(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 3,
        }
    }
    /// Returns the 'ci' Output of this 'BlockLSTMV2' operation.
    pub fn ci(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 4,
        }
    }
    /// Returns the 'co' Output of this 'BlockLSTMV2' operation.
    pub fn co(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 5,
        }
    }
    /// Returns the 'h' Output of this 'BlockLSTMV2' operation.
    pub fn h(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 6,
        }
    }
    /// Returns the 'seq_len_max' Input of this 'BlockLSTMV2' operation.
    pub fn seq_len_max(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'BlockLSTMV2' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'cs_prev' Input of this 'BlockLSTMV2' operation.
    pub fn cs_prev(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'h_prev' Input of this 'BlockLSTMV2' operation.
    pub fn h_prev(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'w' Input of this 'BlockLSTMV2' operation.
    pub fn w(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
    /// Returns the 'wci' Input of this 'BlockLSTMV2' operation.
    pub fn wci(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 5,
        }
    }
    /// Returns the 'wcf' Input of this 'BlockLSTMV2' operation.
    pub fn wcf(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 6,
        }
    }
    /// Returns the 'wco' Input of this 'BlockLSTMV2' operation.
    pub fn wco(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 7,
        }
    }
    /// Returns the 'b' Input of this 'BlockLSTMV2' operation.
    pub fn b(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 8,
        }
    }
}
impl From<BlockLSTMV2Inst> for crate::Operation {
    fn from(inst: BlockLSTMV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `BlockLSTMV2::new().build(seq_len_max, x, cs_prev, h_prev, w, wci, wcf, wco, b, scope)`.
pub fn block_lstmv2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
    O6: ::std::convert::Into<crate::Output>,
    O7: ::std::convert::Into<crate::Output>,
    O8: ::std::convert::Into<crate::Output>,
>(
    seq_len_max: O0,
    x: O1,
    cs_prev: O2,
    h_prev: O3,
    w: O4,
    wci: O5,
    wcf: O6,
    wco: O7,
    b: O8,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    BlockLSTMV2::new().build(seq_len_max, x, cs_prev, h_prev, w, wci, wcf, wco, b, scope)
}

/// Builder for the `BoostedTreesAggregateStats` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct BoostedTreesAggregateStats {
    max_splits: ::std::option::Option<i64>,
    num_buckets: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'BoostedTreesAggregateStats' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct BoostedTreesAggregateStatsInst {
    /// An instance of a fully built BoostedTreesAggregateStats Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl BoostedTreesAggregateStats {
    /// Creates a new `BoostedTreesAggregateStats`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `max_splits` attribute.
    pub fn max_splits<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.max_splits = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `num_buckets` attribute.
    pub fn num_buckets<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.num_buckets = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `BoostedTreesAggregateStats` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
    >(
        &self,
        node_ids: O0,
        gradients: O1,
        hessians: O2,
        feature: O3,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            node_ids.into(),
            gradients.into(),
            hessians.into(),
            feature.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        node_ids: crate::Output,
        gradients: crate::Output,
        hessians: crate::Output,
        feature: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("BoostedTreesAggregateStats", |nd| {
            nd.add_input(node_ids);
            nd.add_input(gradients);
            nd.add_input(hessians);
            nd.add_input(feature);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.max_splits {
                nd.set_attr_int("max_splits", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_buckets {
                nd.set_attr_int("num_buckets", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'BoostedTreesAggregateStats' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        node_ids: crate::Output,
        gradients: crate::Output,
        hessians: crate::Output,
        feature: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<BoostedTreesAggregateStatsInst> {
        let op = scope.new_operation("BoostedTreesAggregateStats", |builder| {
            builder.add_input(node_ids);
            builder.add_input(gradients);
            builder.add_input(hessians);
            builder.add_input(feature);
            if let ::std::option::Option::Some(value) = &self.max_splits {
                builder.set_attr_int("max_splits", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_buckets {
                builder.set_attr_int("num_buckets", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(BoostedTreesAggregateStatsInst { op })
    }
}
impl BoostedTreesAggregateStatsInst {
    /// Returns the 'stats_summary' Output of this 'BoostedTreesAggregateStats' operation.
    pub fn stats_summary(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'node_ids' Input of this 'BoostedTreesAggregateStats' operation.
    pub fn node_ids(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'gradients' Input of this 'BoostedTreesAggregateStats' operation.
    pub fn gradients(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'hessians' Input of this 'BoostedTreesAggregateStats' operation.
    pub fn hessians(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'feature' Input of this 'BoostedTreesAggregateStats' operation.
    pub fn feature(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
}
impl From<BoostedTreesAggregateStatsInst> for crate::Operation {
    fn from(inst: BoostedTreesAggregateStatsInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `BoostedTreesAggregateStats::new().build(node_ids, gradients, hessians, feature, scope)`.
pub fn boosted_trees_aggregate_stats<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
>(
    node_ids: O0,
    gradients: O1,
    hessians: O2,
    feature: O3,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    BoostedTreesAggregateStats::new().build(node_ids, gradients, hessians, feature, scope)
}

/// Builder for the `BoostedTreesBucketize` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct BoostedTreesBucketize {
    num_features: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'BoostedTreesBucketize' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct BoostedTreesBucketizeInst {
    /// An instance of a fully built BoostedTreesBucketize Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl BoostedTreesBucketize {
    /// Creates a new `BoostedTreesBucketize`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `num_features` attribute.
    pub fn num_features<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.num_features = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `BoostedTreesBucketize` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        float_values: O0,
        bucket_boundaries: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(float_values.into(), bucket_boundaries.into(), scope)
    }
    fn build_impl(
        &self,
        float_values: crate::Output,
        bucket_boundaries: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("BoostedTreesBucketize", |nd| {
            nd.add_input(float_values);
            nd.add_input(bucket_boundaries);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.num_features {
                nd.set_attr_int("num_features", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'BoostedTreesBucketize' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        float_values: Vec<crate::Output>,
        bucket_boundaries: Vec<crate::Output>,
        scope: &mut crate::Scope,
    ) -> crate::Result<BoostedTreesBucketizeInst> {
        let op = scope.new_operation("BoostedTreesBucketize", |builder| {
            builder.add_input_list(&float_values);
            builder.add_input_list(&bucket_boundaries);
            builder.set_attr_int("num_features", float_values.clone().len() as i64)?;
            ::std::result::Result::Ok(())
        })?;
        Ok(BoostedTreesBucketizeInst { op })
    }
}
impl BoostedTreesBucketizeInst {
    /// Returns a Vector of buckets for 'buckets' Output of this BoostedTreesBucketize operation.
    pub fn buckets(&self) -> crate::Result<Vec<crate::Output>> {
        let mut Outputs = vec![];
        for i in 0..self.op.get_attr_int("num_features")? as i32 {
            Outputs.push(crate::Output {
                operation: self.op.clone(),
                index: i,
            });
        }
        Ok(Outputs)
    }
    /// Returns a Vector of float_values for 'float_values' Input of this BoostedTreesBucketize operation.
    pub fn float_values(&self) -> crate::Result<Vec<crate::Input>> {
        let mut Inputs = vec![];
        for i in 0..self.op.get_attr_int("num_features")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
    /// Returns a Vector of bucket_boundaries for 'bucket_boundaries' Input of this BoostedTreesBucketize operation.
    pub fn bucket_boundaries(&self) -> crate::Result<Vec<crate::Input>> {
        let dynamic_offset = (self.op.get_attr_int("num_features")? + 1) as i32;
        let mut Inputs = vec![];
        for i in dynamic_offset..dynamic_offset + self.op.get_attr_int("num_features")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
}
impl From<BoostedTreesBucketizeInst> for crate::Operation {
    fn from(inst: BoostedTreesBucketizeInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `BoostedTreesBucketize::new().build(float_values, bucket_boundaries, scope)`.
pub fn boosted_trees_bucketize<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    float_values: O0,
    bucket_boundaries: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    BoostedTreesBucketize::new().build(float_values, bucket_boundaries, scope)
}

/// Builder for the `BoostedTreesCalculateBestFeatureSplit` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct BoostedTreesCalculateBestFeatureSplit {
    logits_dimension: ::std::option::Option<i64>,
    split_type: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'BoostedTreesCalculateBestFeatureSplit' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct BoostedTreesCalculateBestFeatureSplitInst {
    /// An instance of a fully built BoostedTreesCalculateBestFeatureSplit Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl BoostedTreesCalculateBestFeatureSplit {
    /// Creates a new `BoostedTreesCalculateBestFeatureSplit`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `logits_dimension` attribute.
    pub fn logits_dimension<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.logits_dimension = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `split_type` attribute.
    pub fn split_type<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.split_type = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `BoostedTreesCalculateBestFeatureSplit` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
    >(
        &self,
        node_id_range: O0,
        stats_summary: O1,
        l1: O2,
        l2: O3,
        tree_complexity: O4,
        min_node_weight: O5,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            node_id_range.into(),
            stats_summary.into(),
            l1.into(),
            l2.into(),
            tree_complexity.into(),
            min_node_weight.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        node_id_range: crate::Output,
        stats_summary: crate::Output,
        l1: crate::Output,
        l2: crate::Output,
        tree_complexity: crate::Output,
        min_node_weight: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("BoostedTreesCalculateBestFeatureSplit", |nd| {
            nd.add_input(node_id_range);
            nd.add_input(stats_summary);
            nd.add_input(l1);
            nd.add_input(l2);
            nd.add_input(tree_complexity);
            nd.add_input(min_node_weight);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.logits_dimension {
                nd.set_attr_int("logits_dimension", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.split_type {
                nd.set_attr_string("split_type", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'BoostedTreesCalculateBestFeatureSplit' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        node_id_range: crate::Output,
        stats_summary: crate::Output,
        l1: crate::Output,
        l2: crate::Output,
        tree_complexity: crate::Output,
        min_node_weight: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<BoostedTreesCalculateBestFeatureSplitInst> {
        let op = scope.new_operation("BoostedTreesCalculateBestFeatureSplit", |builder| {
            builder.add_input(node_id_range);
            builder.add_input(stats_summary);
            builder.add_input(l1);
            builder.add_input(l2);
            builder.add_input(tree_complexity);
            builder.add_input(min_node_weight);
            if let ::std::option::Option::Some(value) = &self.logits_dimension {
                builder.set_attr_int("logits_dimension", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.split_type {
                builder.set_attr_string("split_type", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(BoostedTreesCalculateBestFeatureSplitInst { op })
    }
}
impl BoostedTreesCalculateBestFeatureSplitInst {
    /// Returns the 'node_ids' Output of this 'BoostedTreesCalculateBestFeatureSplit' operation.
    pub fn node_ids(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'gains' Output of this 'BoostedTreesCalculateBestFeatureSplit' operation.
    pub fn gains(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'feature_dimensions' Output of this 'BoostedTreesCalculateBestFeatureSplit' operation.
    pub fn feature_dimensions(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns the 'thresholds' Output of this 'BoostedTreesCalculateBestFeatureSplit' operation.
    pub fn thresholds(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 3,
        }
    }
    /// Returns the 'left_node_contribs' Output of this 'BoostedTreesCalculateBestFeatureSplit' operation.
    pub fn left_node_contribs(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 4,
        }
    }
    /// Returns the 'right_node_contribs' Output of this 'BoostedTreesCalculateBestFeatureSplit' operation.
    pub fn right_node_contribs(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 5,
        }
    }
    /// Returns the 'split_with_default_directions' Output of this 'BoostedTreesCalculateBestFeatureSplit' operation.
    pub fn split_with_default_directions(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 6,
        }
    }
    /// Returns the 'node_id_range' Input of this 'BoostedTreesCalculateBestFeatureSplit' operation.
    pub fn node_id_range(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'stats_summary' Input of this 'BoostedTreesCalculateBestFeatureSplit' operation.
    pub fn stats_summary(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'l1' Input of this 'BoostedTreesCalculateBestFeatureSplit' operation.
    pub fn l1(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'l2' Input of this 'BoostedTreesCalculateBestFeatureSplit' operation.
    pub fn l2(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'tree_complexity' Input of this 'BoostedTreesCalculateBestFeatureSplit' operation.
    pub fn tree_complexity(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
    /// Returns the 'min_node_weight' Input of this 'BoostedTreesCalculateBestFeatureSplit' operation.
    pub fn min_node_weight(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 5,
        }
    }
}
impl From<BoostedTreesCalculateBestFeatureSplitInst> for crate::Operation {
    fn from(inst: BoostedTreesCalculateBestFeatureSplitInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `BoostedTreesCalculateBestFeatureSplit::new().build(node_id_range, stats_summary, l1, l2, tree_complexity, min_node_weight, scope)`.
pub fn boosted_trees_calculate_best_feature_split<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
>(
    node_id_range: O0,
    stats_summary: O1,
    l1: O2,
    l2: O3,
    tree_complexity: O4,
    min_node_weight: O5,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    BoostedTreesCalculateBestFeatureSplit::new().build(
        node_id_range,
        stats_summary,
        l1,
        l2,
        tree_complexity,
        min_node_weight,
        scope,
    )
}

/// Builder for the `BoostedTreesCalculateBestFeatureSplitV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct BoostedTreesCalculateBestFeatureSplitV2 {
    num_features: ::std::option::Option<i64>,
    logits_dimension: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'BoostedTreesCalculateBestFeatureSplitV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct BoostedTreesCalculateBestFeatureSplitV2Inst {
    /// An instance of a fully built BoostedTreesCalculateBestFeatureSplitV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl BoostedTreesCalculateBestFeatureSplitV2 {
    /// Creates a new `BoostedTreesCalculateBestFeatureSplitV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `num_features` attribute.
    pub fn num_features<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.num_features = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `logits_dimension` attribute.
    pub fn logits_dimension<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.logits_dimension = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `BoostedTreesCalculateBestFeatureSplitV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
        O6: ::std::convert::Into<crate::Output>,
        O7: ::std::convert::Into<crate::Output>,
    >(
        &self,
        node_id_range: O0,
        stats_summaries_list: O1,
        split_types: O2,
        candidate_feature_ids: O3,
        l1: O4,
        l2: O5,
        tree_complexity: O6,
        min_node_weight: O7,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            node_id_range.into(),
            stats_summaries_list.into(),
            split_types.into(),
            candidate_feature_ids.into(),
            l1.into(),
            l2.into(),
            tree_complexity.into(),
            min_node_weight.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        node_id_range: crate::Output,
        stats_summaries_list: crate::Output,
        split_types: crate::Output,
        candidate_feature_ids: crate::Output,
        l1: crate::Output,
        l2: crate::Output,
        tree_complexity: crate::Output,
        min_node_weight: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("BoostedTreesCalculateBestFeatureSplitV2", |nd| {
            nd.add_input(node_id_range);
            nd.add_input(stats_summaries_list);
            nd.add_input(split_types);
            nd.add_input(candidate_feature_ids);
            nd.add_input(l1);
            nd.add_input(l2);
            nd.add_input(tree_complexity);
            nd.add_input(min_node_weight);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.num_features {
                nd.set_attr_int("num_features", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.logits_dimension {
                nd.set_attr_int("logits_dimension", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'BoostedTreesCalculateBestFeatureSplitV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        node_id_range: crate::Output,
        stats_summaries_list: Vec<crate::Output>,
        split_types: crate::Output,
        candidate_feature_ids: crate::Output,
        l1: crate::Output,
        l2: crate::Output,
        tree_complexity: crate::Output,
        min_node_weight: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<BoostedTreesCalculateBestFeatureSplitV2Inst> {
        let op = scope.new_operation("BoostedTreesCalculateBestFeatureSplitV2", |builder| {
            builder.add_input(node_id_range);
            builder.add_input_list(&stats_summaries_list);
            builder.add_input(split_types);
            builder.add_input(candidate_feature_ids);
            builder.add_input(l1);
            builder.add_input(l2);
            builder.add_input(tree_complexity);
            builder.add_input(min_node_weight);
            builder.set_attr_int("num_features", stats_summaries_list.clone().len() as i64)?;
            if let ::std::option::Option::Some(value) = &self.logits_dimension {
                builder.set_attr_int("logits_dimension", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(BoostedTreesCalculateBestFeatureSplitV2Inst { op })
    }
}
impl BoostedTreesCalculateBestFeatureSplitV2Inst {
    /// Returns the 'node_ids' Output of this 'BoostedTreesCalculateBestFeatureSplitV2' operation.
    pub fn node_ids(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'gains' Output of this 'BoostedTreesCalculateBestFeatureSplitV2' operation.
    pub fn gains(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'feature_ids' Output of this 'BoostedTreesCalculateBestFeatureSplitV2' operation.
    pub fn feature_ids(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns the 'feature_dimensions' Output of this 'BoostedTreesCalculateBestFeatureSplitV2' operation.
    pub fn feature_dimensions(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 3,
        }
    }
    /// Returns the 'thresholds' Output of this 'BoostedTreesCalculateBestFeatureSplitV2' operation.
    pub fn thresholds(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 4,
        }
    }
    /// Returns the 'left_node_contribs' Output of this 'BoostedTreesCalculateBestFeatureSplitV2' operation.
    pub fn left_node_contribs(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 5,
        }
    }
    /// Returns the 'right_node_contribs' Output of this 'BoostedTreesCalculateBestFeatureSplitV2' operation.
    pub fn right_node_contribs(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 6,
        }
    }
    /// Returns the 'split_with_default_directions' Output of this 'BoostedTreesCalculateBestFeatureSplitV2' operation.
    pub fn split_with_default_directions(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 7,
        }
    }
    /// Returns the 'node_id_range' Input of this 'BoostedTreesCalculateBestFeatureSplitV2' operation.
    pub fn node_id_range(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns a Vector of stats_summaries_list for 'stats_summaries_list' Input of this BoostedTreesCalculateBestFeatureSplitV2 operation.
    pub fn stats_summaries_list(&self) -> crate::Result<Vec<crate::Input>> {
        let mut Inputs = vec![];
        for i in 1..self.op.get_attr_int("num_features")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
    /// Returns the 'split_types' Input of this 'BoostedTreesCalculateBestFeatureSplitV2' operation.
    pub fn split_types(&self) -> crate::Result<crate::Input> {
        let dynamic_offset = (self.op.get_attr_int("num_features")? + 2) as i32;
        Ok(crate::Input {
            operation: &self.op,
            index: dynamic_offset,
        })
    }
    /// Returns the 'candidate_feature_ids' Input of this 'BoostedTreesCalculateBestFeatureSplitV2' operation.
    pub fn candidate_feature_ids(&self) -> crate::Result<crate::Input> {
        let dynamic_offset = (self.op.get_attr_int("num_features")? + 3) as i32;
        Ok(crate::Input {
            operation: &self.op,
            index: dynamic_offset,
        })
    }
    /// Returns the 'l1' Input of this 'BoostedTreesCalculateBestFeatureSplitV2' operation.
    pub fn l1(&self) -> crate::Result<crate::Input> {
        let dynamic_offset = (self.op.get_attr_int("num_features")? + 4) as i32;
        Ok(crate::Input {
            operation: &self.op,
            index: dynamic_offset,
        })
    }
    /// Returns the 'l2' Input of this 'BoostedTreesCalculateBestFeatureSplitV2' operation.
    pub fn l2(&self) -> crate::Result<crate::Input> {
        let dynamic_offset = (self.op.get_attr_int("num_features")? + 5) as i32;
        Ok(crate::Input {
            operation: &self.op,
            index: dynamic_offset,
        })
    }
    /// Returns the 'tree_complexity' Input of this 'BoostedTreesCalculateBestFeatureSplitV2' operation.
    pub fn tree_complexity(&self) -> crate::Result<crate::Input> {
        let dynamic_offset = (self.op.get_attr_int("num_features")? + 6) as i32;
        Ok(crate::Input {
            operation: &self.op,
            index: dynamic_offset,
        })
    }
    /// Returns the 'min_node_weight' Input of this 'BoostedTreesCalculateBestFeatureSplitV2' operation.
    pub fn min_node_weight(&self) -> crate::Result<crate::Input> {
        let dynamic_offset = (self.op.get_attr_int("num_features")? + 7) as i32;
        Ok(crate::Input {
            operation: &self.op,
            index: dynamic_offset,
        })
    }
}
impl From<BoostedTreesCalculateBestFeatureSplitV2Inst> for crate::Operation {
    fn from(inst: BoostedTreesCalculateBestFeatureSplitV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `BoostedTreesCalculateBestFeatureSplitV2::new().build(node_id_range, stats_summaries_list, split_types, candidate_feature_ids, l1, l2, tree_complexity, min_node_weight, scope)`.
pub fn boosted_trees_calculate_best_feature_split_v2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
    O6: ::std::convert::Into<crate::Output>,
    O7: ::std::convert::Into<crate::Output>,
>(
    node_id_range: O0,
    stats_summaries_list: O1,
    split_types: O2,
    candidate_feature_ids: O3,
    l1: O4,
    l2: O5,
    tree_complexity: O6,
    min_node_weight: O7,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    BoostedTreesCalculateBestFeatureSplitV2::new().build(
        node_id_range,
        stats_summaries_list,
        split_types,
        candidate_feature_ids,
        l1,
        l2,
        tree_complexity,
        min_node_weight,
        scope,
    )
}

/// Builder for the `BoostedTreesCalculateBestGainsPerFeature` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct BoostedTreesCalculateBestGainsPerFeature {
    max_splits: ::std::option::Option<i64>,
    num_features: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'BoostedTreesCalculateBestGainsPerFeature' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct BoostedTreesCalculateBestGainsPerFeatureInst {
    /// An instance of a fully built BoostedTreesCalculateBestGainsPerFeature Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl BoostedTreesCalculateBestGainsPerFeature {
    /// Creates a new `BoostedTreesCalculateBestGainsPerFeature`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `max_splits` attribute.
    pub fn max_splits<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.max_splits = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `num_features` attribute.
    pub fn num_features<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.num_features = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `BoostedTreesCalculateBestGainsPerFeature` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
    >(
        &self,
        node_id_range: O0,
        stats_summary_list: O1,
        l1: O2,
        l2: O3,
        tree_complexity: O4,
        min_node_weight: O5,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            node_id_range.into(),
            stats_summary_list.into(),
            l1.into(),
            l2.into(),
            tree_complexity.into(),
            min_node_weight.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        node_id_range: crate::Output,
        stats_summary_list: crate::Output,
        l1: crate::Output,
        l2: crate::Output,
        tree_complexity: crate::Output,
        min_node_weight: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("BoostedTreesCalculateBestGainsPerFeature", |nd| {
            nd.add_input(node_id_range);
            nd.add_input(stats_summary_list);
            nd.add_input(l1);
            nd.add_input(l2);
            nd.add_input(tree_complexity);
            nd.add_input(min_node_weight);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.max_splits {
                nd.set_attr_int("max_splits", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_features {
                nd.set_attr_int("num_features", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'BoostedTreesCalculateBestGainsPerFeature' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        node_id_range: crate::Output,
        stats_summary_list: Vec<crate::Output>,
        l1: crate::Output,
        l2: crate::Output,
        tree_complexity: crate::Output,
        min_node_weight: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<BoostedTreesCalculateBestGainsPerFeatureInst> {
        let op = scope.new_operation("BoostedTreesCalculateBestGainsPerFeature", |builder| {
            builder.add_input(node_id_range);
            builder.add_input_list(&stats_summary_list);
            builder.add_input(l1);
            builder.add_input(l2);
            builder.add_input(tree_complexity);
            builder.add_input(min_node_weight);
            if let ::std::option::Option::Some(value) = &self.max_splits {
                builder.set_attr_int("max_splits", *value)?;
            }
            builder.set_attr_int("num_features", stats_summary_list.clone().len() as i64)?;
            ::std::result::Result::Ok(())
        })?;
        Ok(BoostedTreesCalculateBestGainsPerFeatureInst { op })
    }
}
impl BoostedTreesCalculateBestGainsPerFeatureInst {
    /// Returns a Vector of node_ids_list for 'node_ids_list' Output of this BoostedTreesCalculateBestGainsPerFeature operation.
    pub fn node_ids_list(&self) -> crate::Result<Vec<crate::Output>> {
        let mut Outputs = vec![];
        for i in 0..self.op.get_attr_int("num_features")? as i32 {
            Outputs.push(crate::Output {
                operation: self.op.clone(),
                index: i,
            });
        }
        Ok(Outputs)
    }
    /// Returns a Vector of gains_list for 'gains_list' Output of this BoostedTreesCalculateBestGainsPerFeature operation.
    pub fn gains_list(&self) -> crate::Result<Vec<crate::Output>> {
        let dynamic_offset = (self.op.get_attr_int("num_features")? + 1) as i32;
        let mut Outputs = vec![];
        for i in dynamic_offset..dynamic_offset + self.op.get_attr_int("num_features")? as i32 {
            Outputs.push(crate::Output {
                operation: self.op.clone(),
                index: i,
            });
        }
        Ok(Outputs)
    }
    /// Returns a Vector of thresholds_list for 'thresholds_list' Output of this BoostedTreesCalculateBestGainsPerFeature operation.
    pub fn thresholds_list(&self) -> crate::Result<Vec<crate::Output>> {
        let dynamic_offset = (2 * self.op.get_attr_int("num_features")? + 2) as i32;
        let mut Outputs = vec![];
        for i in dynamic_offset..dynamic_offset + self.op.get_attr_int("num_features")? as i32 {
            Outputs.push(crate::Output {
                operation: self.op.clone(),
                index: i,
            });
        }
        Ok(Outputs)
    }
    /// Returns a Vector of left_node_contribs_list for 'left_node_contribs_list' Output of this BoostedTreesCalculateBestGainsPerFeature operation.
    pub fn left_node_contribs_list(&self) -> crate::Result<Vec<crate::Output>> {
        let dynamic_offset = (3 * self.op.get_attr_int("num_features")? + 3) as i32;
        let mut Outputs = vec![];
        for i in dynamic_offset..dynamic_offset + self.op.get_attr_int("num_features")? as i32 {
            Outputs.push(crate::Output {
                operation: self.op.clone(),
                index: i,
            });
        }
        Ok(Outputs)
    }
    /// Returns a Vector of right_node_contribs_list for 'right_node_contribs_list' Output of this BoostedTreesCalculateBestGainsPerFeature operation.
    pub fn right_node_contribs_list(&self) -> crate::Result<Vec<crate::Output>> {
        let dynamic_offset = (4 * self.op.get_attr_int("num_features")? + 4) as i32;
        let mut Outputs = vec![];
        for i in dynamic_offset..dynamic_offset + self.op.get_attr_int("num_features")? as i32 {
            Outputs.push(crate::Output {
                operation: self.op.clone(),
                index: i,
            });
        }
        Ok(Outputs)
    }
    /// Returns the 'node_id_range' Input of this 'BoostedTreesCalculateBestGainsPerFeature' operation.
    pub fn node_id_range(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns a Vector of stats_summary_list for 'stats_summary_list' Input of this BoostedTreesCalculateBestGainsPerFeature operation.
    pub fn stats_summary_list(&self) -> crate::Result<Vec<crate::Input>> {
        let mut Inputs = vec![];
        for i in 1..self.op.get_attr_int("num_features")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
    /// Returns the 'l1' Input of this 'BoostedTreesCalculateBestGainsPerFeature' operation.
    pub fn l1(&self) -> crate::Result<crate::Input> {
        let dynamic_offset = (self.op.get_attr_int("num_features")? + 2) as i32;
        Ok(crate::Input {
            operation: &self.op,
            index: dynamic_offset,
        })
    }
    /// Returns the 'l2' Input of this 'BoostedTreesCalculateBestGainsPerFeature' operation.
    pub fn l2(&self) -> crate::Result<crate::Input> {
        let dynamic_offset = (self.op.get_attr_int("num_features")? + 3) as i32;
        Ok(crate::Input {
            operation: &self.op,
            index: dynamic_offset,
        })
    }
    /// Returns the 'tree_complexity' Input of this 'BoostedTreesCalculateBestGainsPerFeature' operation.
    pub fn tree_complexity(&self) -> crate::Result<crate::Input> {
        let dynamic_offset = (self.op.get_attr_int("num_features")? + 4) as i32;
        Ok(crate::Input {
            operation: &self.op,
            index: dynamic_offset,
        })
    }
    /// Returns the 'min_node_weight' Input of this 'BoostedTreesCalculateBestGainsPerFeature' operation.
    pub fn min_node_weight(&self) -> crate::Result<crate::Input> {
        let dynamic_offset = (self.op.get_attr_int("num_features")? + 5) as i32;
        Ok(crate::Input {
            operation: &self.op,
            index: dynamic_offset,
        })
    }
}
impl From<BoostedTreesCalculateBestGainsPerFeatureInst> for crate::Operation {
    fn from(inst: BoostedTreesCalculateBestGainsPerFeatureInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `BoostedTreesCalculateBestGainsPerFeature::new().build(node_id_range, stats_summary_list, l1, l2, tree_complexity, min_node_weight, scope)`.
pub fn boosted_trees_calculate_best_gains_per_feature<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
>(
    node_id_range: O0,
    stats_summary_list: O1,
    l1: O2,
    l2: O3,
    tree_complexity: O4,
    min_node_weight: O5,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    BoostedTreesCalculateBestGainsPerFeature::new().build(
        node_id_range,
        stats_summary_list,
        l1,
        l2,
        tree_complexity,
        min_node_weight,
        scope,
    )
}

/// Builder for the `BoostedTreesCenterBias` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct BoostedTreesCenterBias {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'BoostedTreesCenterBias' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct BoostedTreesCenterBiasInst {
    /// An instance of a fully built BoostedTreesCenterBias Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl BoostedTreesCenterBias {
    /// Creates a new `BoostedTreesCenterBias`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `BoostedTreesCenterBias` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
    >(
        &self,
        tree_ensemble_handle: O0,
        mean_gradients: O1,
        mean_hessians: O2,
        l1: O3,
        l2: O4,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            tree_ensemble_handle.into(),
            mean_gradients.into(),
            mean_hessians.into(),
            l1.into(),
            l2.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        tree_ensemble_handle: crate::Output,
        mean_gradients: crate::Output,
        mean_hessians: crate::Output,
        l1: crate::Output,
        l2: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("BoostedTreesCenterBias", |nd| {
            nd.add_input(tree_ensemble_handle);
            nd.add_input(mean_gradients);
            nd.add_input(mean_hessians);
            nd.add_input(l1);
            nd.add_input(l2);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'BoostedTreesCenterBias' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        tree_ensemble_handle: crate::Output,
        mean_gradients: crate::Output,
        mean_hessians: crate::Output,
        l1: crate::Output,
        l2: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<BoostedTreesCenterBiasInst> {
        let op = scope.new_operation("BoostedTreesCenterBias", |builder| {
            builder.add_input(tree_ensemble_handle);
            builder.add_input(mean_gradients);
            builder.add_input(mean_hessians);
            builder.add_input(l1);
            builder.add_input(l2);
            ::std::result::Result::Ok(())
        })?;
        Ok(BoostedTreesCenterBiasInst { op })
    }
}
impl BoostedTreesCenterBiasInst {
    /// Returns the 'continue_centering' Output of this 'BoostedTreesCenterBias' operation.
    pub fn continue_centering(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'tree_ensemble_handle' Input of this 'BoostedTreesCenterBias' operation.
    pub fn tree_ensemble_handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'mean_gradients' Input of this 'BoostedTreesCenterBias' operation.
    pub fn mean_gradients(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'mean_hessians' Input of this 'BoostedTreesCenterBias' operation.
    pub fn mean_hessians(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'l1' Input of this 'BoostedTreesCenterBias' operation.
    pub fn l1(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'l2' Input of this 'BoostedTreesCenterBias' operation.
    pub fn l2(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
}
impl From<BoostedTreesCenterBiasInst> for crate::Operation {
    fn from(inst: BoostedTreesCenterBiasInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `BoostedTreesCenterBias::new().build(tree_ensemble_handle, mean_gradients, mean_hessians, l1, l2, scope)`.
pub fn boosted_trees_center_bias<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
>(
    tree_ensemble_handle: O0,
    mean_gradients: O1,
    mean_hessians: O2,
    l1: O3,
    l2: O4,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    BoostedTreesCenterBias::new().build(
        tree_ensemble_handle,
        mean_gradients,
        mean_hessians,
        l1,
        l2,
        scope,
    )
}

/// Builder for the `BoostedTreesCreateEnsemble` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct BoostedTreesCreateEnsemble {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'BoostedTreesCreateEnsemble' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct BoostedTreesCreateEnsembleInst {
    /// An instance of a fully built BoostedTreesCreateEnsemble Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl BoostedTreesCreateEnsemble {
    /// Creates a new `BoostedTreesCreateEnsemble`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `BoostedTreesCreateEnsemble` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        tree_ensemble_handle: O0,
        stamp_token: O1,
        tree_ensemble_serialized: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            tree_ensemble_handle.into(),
            stamp_token.into(),
            tree_ensemble_serialized.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        tree_ensemble_handle: crate::Output,
        stamp_token: crate::Output,
        tree_ensemble_serialized: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("BoostedTreesCreateEnsemble", |nd| {
            nd.add_input(tree_ensemble_handle);
            nd.add_input(stamp_token);
            nd.add_input(tree_ensemble_serialized);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'BoostedTreesCreateEnsemble' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        tree_ensemble_handle: crate::Output,
        stamp_token: crate::Output,
        tree_ensemble_serialized: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<BoostedTreesCreateEnsembleInst> {
        let op = scope.new_operation("BoostedTreesCreateEnsemble", |builder| {
            builder.add_input(tree_ensemble_handle);
            builder.add_input(stamp_token);
            builder.add_input(tree_ensemble_serialized);
            ::std::result::Result::Ok(())
        })?;
        Ok(BoostedTreesCreateEnsembleInst { op })
    }
}
impl BoostedTreesCreateEnsembleInst {
    /// Returns the 'tree_ensemble_handle' Input of this 'BoostedTreesCreateEnsemble' operation.
    pub fn tree_ensemble_handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'stamp_token' Input of this 'BoostedTreesCreateEnsemble' operation.
    pub fn stamp_token(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'tree_ensemble_serialized' Input of this 'BoostedTreesCreateEnsemble' operation.
    pub fn tree_ensemble_serialized(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<BoostedTreesCreateEnsembleInst> for crate::Operation {
    fn from(inst: BoostedTreesCreateEnsembleInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `BoostedTreesCreateEnsemble::new().build(tree_ensemble_handle, stamp_token, tree_ensemble_serialized, scope)`.
pub fn boosted_trees_create_ensemble<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    tree_ensemble_handle: O0,
    stamp_token: O1,
    tree_ensemble_serialized: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    BoostedTreesCreateEnsemble::new().build(
        tree_ensemble_handle,
        stamp_token,
        tree_ensemble_serialized,
        scope,
    )
}

/// Builder for the `BoostedTreesCreateQuantileStreamResource` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct BoostedTreesCreateQuantileStreamResource {
    max_elements: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'BoostedTreesCreateQuantileStreamResource' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct BoostedTreesCreateQuantileStreamResourceInst {
    /// An instance of a fully built BoostedTreesCreateQuantileStreamResource Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl BoostedTreesCreateQuantileStreamResource {
    /// Creates a new `BoostedTreesCreateQuantileStreamResource`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `max_elements` attribute.
    pub fn max_elements<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.max_elements = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `BoostedTreesCreateQuantileStreamResource` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        quantile_stream_resource_handle: O0,
        epsilon: O1,
        num_streams: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            quantile_stream_resource_handle.into(),
            epsilon.into(),
            num_streams.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        quantile_stream_resource_handle: crate::Output,
        epsilon: crate::Output,
        num_streams: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("BoostedTreesCreateQuantileStreamResource", |nd| {
            nd.add_input(quantile_stream_resource_handle);
            nd.add_input(epsilon);
            nd.add_input(num_streams);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.max_elements {
                nd.set_attr_int("max_elements", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'BoostedTreesCreateQuantileStreamResource' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        quantile_stream_resource_handle: crate::Output,
        epsilon: crate::Output,
        num_streams: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<BoostedTreesCreateQuantileStreamResourceInst> {
        let op = scope.new_operation("BoostedTreesCreateQuantileStreamResource", |builder| {
            builder.add_input(quantile_stream_resource_handle);
            builder.add_input(epsilon);
            builder.add_input(num_streams);
            if let ::std::option::Option::Some(value) = &self.max_elements {
                builder.set_attr_int("max_elements", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(BoostedTreesCreateQuantileStreamResourceInst { op })
    }
}
impl BoostedTreesCreateQuantileStreamResourceInst {
    /// Returns the 'quantile_stream_resource_handle' Input of this 'BoostedTreesCreateQuantileStreamResource' operation.
    pub fn quantile_stream_resource_handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'epsilon' Input of this 'BoostedTreesCreateQuantileStreamResource' operation.
    pub fn epsilon(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'num_streams' Input of this 'BoostedTreesCreateQuantileStreamResource' operation.
    pub fn num_streams(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<BoostedTreesCreateQuantileStreamResourceInst> for crate::Operation {
    fn from(inst: BoostedTreesCreateQuantileStreamResourceInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `BoostedTreesCreateQuantileStreamResource::new().build(quantile_stream_resource_handle, epsilon, num_streams, scope)`.
pub fn boosted_trees_create_quantile_stream_resource<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    quantile_stream_resource_handle: O0,
    epsilon: O1,
    num_streams: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    BoostedTreesCreateQuantileStreamResource::new().build(
        quantile_stream_resource_handle,
        epsilon,
        num_streams,
        scope,
    )
}

/// Builder for the `BoostedTreesDeserializeEnsemble` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct BoostedTreesDeserializeEnsemble {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'BoostedTreesDeserializeEnsemble' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct BoostedTreesDeserializeEnsembleInst {
    /// An instance of a fully built BoostedTreesDeserializeEnsemble Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl BoostedTreesDeserializeEnsemble {
    /// Creates a new `BoostedTreesDeserializeEnsemble`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `BoostedTreesDeserializeEnsemble` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        tree_ensemble_handle: O0,
        stamp_token: O1,
        tree_ensemble_serialized: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            tree_ensemble_handle.into(),
            stamp_token.into(),
            tree_ensemble_serialized.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        tree_ensemble_handle: crate::Output,
        stamp_token: crate::Output,
        tree_ensemble_serialized: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("BoostedTreesDeserializeEnsemble", |nd| {
            nd.add_input(tree_ensemble_handle);
            nd.add_input(stamp_token);
            nd.add_input(tree_ensemble_serialized);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'BoostedTreesDeserializeEnsemble' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        tree_ensemble_handle: crate::Output,
        stamp_token: crate::Output,
        tree_ensemble_serialized: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<BoostedTreesDeserializeEnsembleInst> {
        let op = scope.new_operation("BoostedTreesDeserializeEnsemble", |builder| {
            builder.add_input(tree_ensemble_handle);
            builder.add_input(stamp_token);
            builder.add_input(tree_ensemble_serialized);
            ::std::result::Result::Ok(())
        })?;
        Ok(BoostedTreesDeserializeEnsembleInst { op })
    }
}
impl BoostedTreesDeserializeEnsembleInst {
    /// Returns the 'tree_ensemble_handle' Input of this 'BoostedTreesDeserializeEnsemble' operation.
    pub fn tree_ensemble_handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'stamp_token' Input of this 'BoostedTreesDeserializeEnsemble' operation.
    pub fn stamp_token(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'tree_ensemble_serialized' Input of this 'BoostedTreesDeserializeEnsemble' operation.
    pub fn tree_ensemble_serialized(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<BoostedTreesDeserializeEnsembleInst> for crate::Operation {
    fn from(inst: BoostedTreesDeserializeEnsembleInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `BoostedTreesDeserializeEnsemble::new().build(tree_ensemble_handle, stamp_token, tree_ensemble_serialized, scope)`.
pub fn boosted_trees_deserialize_ensemble<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    tree_ensemble_handle: O0,
    stamp_token: O1,
    tree_ensemble_serialized: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    BoostedTreesDeserializeEnsemble::new().build(
        tree_ensemble_handle,
        stamp_token,
        tree_ensemble_serialized,
        scope,
    )
}

/// Builder for the `BoostedTreesEnsembleResourceHandleOp` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct BoostedTreesEnsembleResourceHandleOp {
    container: ::std::option::Option<::std::string::String>,
    shared_name: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'BoostedTreesEnsembleResourceHandleOp' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct BoostedTreesEnsembleResourceHandleOpInst {
    /// An instance of a fully built BoostedTreesEnsembleResourceHandleOp Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl BoostedTreesEnsembleResourceHandleOp {
    /// Creates a new `BoostedTreesEnsembleResourceHandleOp`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `container` attribute.
    pub fn container<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.container = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shared_name` attribute.
    pub fn shared_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.shared_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `BoostedTreesEnsembleResourceHandleOp` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("BoostedTreesEnsembleResourceHandleOp", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.container {
                nd.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                nd.set_attr_string("shared_name", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'BoostedTreesEnsembleResourceHandleOp' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        scope: &mut crate::Scope,
    ) -> crate::Result<BoostedTreesEnsembleResourceHandleOpInst> {
        let op = scope.new_operation("BoostedTreesEnsembleResourceHandleOp", |builder| {
            if let ::std::option::Option::Some(value) = &self.container {
                builder.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                builder.set_attr_string("shared_name", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(BoostedTreesEnsembleResourceHandleOpInst { op })
    }
}
impl BoostedTreesEnsembleResourceHandleOpInst {
    /// Returns the 'resource' Output of this 'BoostedTreesEnsembleResourceHandleOp' operation.
    pub fn resource(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
}
impl From<BoostedTreesEnsembleResourceHandleOpInst> for crate::Operation {
    fn from(inst: BoostedTreesEnsembleResourceHandleOpInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `BoostedTreesEnsembleResourceHandleOp::new().build(scope)`.
pub fn boosted_trees_ensemble_resource_handle_op(
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    BoostedTreesEnsembleResourceHandleOp::new().build(scope)
}

/// Builder for the `BoostedTreesExampleDebugOutputs` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct BoostedTreesExampleDebugOutputs {
    num_bucketized_features: ::std::option::Option<i64>,
    logits_dimension: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'BoostedTreesExampleDebugOutputs' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct BoostedTreesExampleDebugOutputsInst {
    /// An instance of a fully built BoostedTreesExampleDebugOutputs Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl BoostedTreesExampleDebugOutputs {
    /// Creates a new `BoostedTreesExampleDebugOutputs`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `num_bucketized_features` attribute.
    pub fn num_bucketized_features<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.num_bucketized_features = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `logits_dimension` attribute.
    pub fn logits_dimension<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.logits_dimension = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `BoostedTreesExampleDebugOutputs` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        tree_ensemble_handle: O0,
        bucketized_features: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            tree_ensemble_handle.into(),
            bucketized_features.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        tree_ensemble_handle: crate::Output,
        bucketized_features: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("BoostedTreesExampleDebugOutputs", |nd| {
            nd.add_input(tree_ensemble_handle);
            nd.add_input(bucketized_features);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.num_bucketized_features {
                nd.set_attr_int("num_bucketized_features", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.logits_dimension {
                nd.set_attr_int("logits_dimension", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'BoostedTreesExampleDebugOutputs' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        tree_ensemble_handle: crate::Output,
        bucketized_features: Vec<crate::Output>,
        scope: &mut crate::Scope,
    ) -> crate::Result<BoostedTreesExampleDebugOutputsInst> {
        let op = scope.new_operation("BoostedTreesExampleDebugOutputs", |builder| {
            builder.add_input(tree_ensemble_handle);
            builder.add_input_list(&bucketized_features);
            builder.set_attr_int(
                "num_bucketized_features",
                bucketized_features.clone().len() as i64,
            )?;
            if let ::std::option::Option::Some(value) = &self.logits_dimension {
                builder.set_attr_int("logits_dimension", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(BoostedTreesExampleDebugOutputsInst { op })
    }
}
impl BoostedTreesExampleDebugOutputsInst {
    /// Returns the 'examples_debug_outputs_serialized' Output of this 'BoostedTreesExampleDebugOutputs' operation.
    pub fn examples_debug_outputs_serialized(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'tree_ensemble_handle' Input of this 'BoostedTreesExampleDebugOutputs' operation.
    pub fn tree_ensemble_handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns a Vector of bucketized_features for 'bucketized_features' Input of this BoostedTreesExampleDebugOutputs operation.
    pub fn bucketized_features(&self) -> crate::Result<Vec<crate::Input>> {
        let mut Inputs = vec![];
        for i in 1..self.op.get_attr_int("num_bucketized_features")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
}
impl From<BoostedTreesExampleDebugOutputsInst> for crate::Operation {
    fn from(inst: BoostedTreesExampleDebugOutputsInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `BoostedTreesExampleDebugOutputs::new().build(tree_ensemble_handle, bucketized_features, scope)`.
pub fn boosted_trees_example_debug_outputs<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    tree_ensemble_handle: O0,
    bucketized_features: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    BoostedTreesExampleDebugOutputs::new().build(tree_ensemble_handle, bucketized_features, scope)
}

/// Builder for the `BoostedTreesFlushQuantileSummaries` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct BoostedTreesFlushQuantileSummaries {
    num_features: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'BoostedTreesFlushQuantileSummaries' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct BoostedTreesFlushQuantileSummariesInst {
    /// An instance of a fully built BoostedTreesFlushQuantileSummaries Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl BoostedTreesFlushQuantileSummaries {
    /// Creates a new `BoostedTreesFlushQuantileSummaries`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `num_features` attribute.
    pub fn num_features<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.num_features = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `BoostedTreesFlushQuantileSummaries` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        quantile_stream_resource_handle: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(quantile_stream_resource_handle.into(), scope)
    }
    fn build_impl(
        &self,
        quantile_stream_resource_handle: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("BoostedTreesFlushQuantileSummaries", |nd| {
            nd.add_input(quantile_stream_resource_handle);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.num_features {
                nd.set_attr_int("num_features", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'BoostedTreesFlushQuantileSummaries' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        quantile_stream_resource_handle: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<BoostedTreesFlushQuantileSummariesInst> {
        let op = scope.new_operation("BoostedTreesFlushQuantileSummaries", |builder| {
            builder.add_input(quantile_stream_resource_handle);
            if let ::std::option::Option::Some(value) = &self.num_features {
                builder.set_attr_int("num_features", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(BoostedTreesFlushQuantileSummariesInst { op })
    }
}
impl BoostedTreesFlushQuantileSummariesInst {
    /// Returns a Vector of summaries for 'summaries' Output of this BoostedTreesFlushQuantileSummaries operation.
    pub fn summaries(&self) -> crate::Result<Vec<crate::Output>> {
        let mut Outputs = vec![];
        for i in 0..self.op.get_attr_int("num_features")? as i32 {
            Outputs.push(crate::Output {
                operation: self.op.clone(),
                index: i,
            });
        }
        Ok(Outputs)
    }
    /// Returns the 'quantile_stream_resource_handle' Input of this 'BoostedTreesFlushQuantileSummaries' operation.
    pub fn quantile_stream_resource_handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<BoostedTreesFlushQuantileSummariesInst> for crate::Operation {
    fn from(inst: BoostedTreesFlushQuantileSummariesInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `BoostedTreesFlushQuantileSummaries::new().build(quantile_stream_resource_handle, scope)`.
pub fn boosted_trees_flush_quantile_summaries<O0: ::std::convert::Into<crate::Output>>(
    quantile_stream_resource_handle: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    BoostedTreesFlushQuantileSummaries::new().build(quantile_stream_resource_handle, scope)
}

/// Builder for the `BoostedTreesGetEnsembleStates` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct BoostedTreesGetEnsembleStates {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'BoostedTreesGetEnsembleStates' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct BoostedTreesGetEnsembleStatesInst {
    /// An instance of a fully built BoostedTreesGetEnsembleStates Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl BoostedTreesGetEnsembleStates {
    /// Creates a new `BoostedTreesGetEnsembleStates`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `BoostedTreesGetEnsembleStates` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        tree_ensemble_handle: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(tree_ensemble_handle.into(), scope)
    }
    fn build_impl(
        &self,
        tree_ensemble_handle: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("BoostedTreesGetEnsembleStates", |nd| {
            nd.add_input(tree_ensemble_handle);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'BoostedTreesGetEnsembleStates' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        tree_ensemble_handle: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<BoostedTreesGetEnsembleStatesInst> {
        let op = scope.new_operation("BoostedTreesGetEnsembleStates", |builder| {
            builder.add_input(tree_ensemble_handle);
            ::std::result::Result::Ok(())
        })?;
        Ok(BoostedTreesGetEnsembleStatesInst { op })
    }
}
impl BoostedTreesGetEnsembleStatesInst {
    /// Returns the 'stamp_token' Output of this 'BoostedTreesGetEnsembleStates' operation.
    pub fn stamp_token(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'num_trees' Output of this 'BoostedTreesGetEnsembleStates' operation.
    pub fn num_trees(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'num_finalized_trees' Output of this 'BoostedTreesGetEnsembleStates' operation.
    pub fn num_finalized_trees(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns the 'num_attempted_layers' Output of this 'BoostedTreesGetEnsembleStates' operation.
    pub fn num_attempted_layers(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 3,
        }
    }
    /// Returns the 'last_layer_nodes_range' Output of this 'BoostedTreesGetEnsembleStates' operation.
    pub fn last_layer_nodes_range(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 4,
        }
    }
    /// Returns the 'tree_ensemble_handle' Input of this 'BoostedTreesGetEnsembleStates' operation.
    pub fn tree_ensemble_handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<BoostedTreesGetEnsembleStatesInst> for crate::Operation {
    fn from(inst: BoostedTreesGetEnsembleStatesInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `BoostedTreesGetEnsembleStates::new().build(tree_ensemble_handle, scope)`.
pub fn boosted_trees_get_ensemble_states<O0: ::std::convert::Into<crate::Output>>(
    tree_ensemble_handle: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    BoostedTreesGetEnsembleStates::new().build(tree_ensemble_handle, scope)
}

/// Builder for the `BoostedTreesMakeQuantileSummaries` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct BoostedTreesMakeQuantileSummaries {
    num_features: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'BoostedTreesMakeQuantileSummaries' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct BoostedTreesMakeQuantileSummariesInst {
    /// An instance of a fully built BoostedTreesMakeQuantileSummaries Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl BoostedTreesMakeQuantileSummaries {
    /// Creates a new `BoostedTreesMakeQuantileSummaries`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `num_features` attribute.
    pub fn num_features<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.num_features = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `BoostedTreesMakeQuantileSummaries` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        float_values: O0,
        example_weights: O1,
        epsilon: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            float_values.into(),
            example_weights.into(),
            epsilon.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        float_values: crate::Output,
        example_weights: crate::Output,
        epsilon: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("BoostedTreesMakeQuantileSummaries", |nd| {
            nd.add_input(float_values);
            nd.add_input(example_weights);
            nd.add_input(epsilon);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.num_features {
                nd.set_attr_int("num_features", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'BoostedTreesMakeQuantileSummaries' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        float_values: Vec<crate::Output>,
        example_weights: crate::Output,
        epsilon: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<BoostedTreesMakeQuantileSummariesInst> {
        let op = scope.new_operation("BoostedTreesMakeQuantileSummaries", |builder| {
            builder.add_input_list(&float_values);
            builder.add_input(example_weights);
            builder.add_input(epsilon);
            builder.set_attr_int("num_features", float_values.clone().len() as i64)?;
            ::std::result::Result::Ok(())
        })?;
        Ok(BoostedTreesMakeQuantileSummariesInst { op })
    }
}
impl BoostedTreesMakeQuantileSummariesInst {
    /// Returns a Vector of summaries for 'summaries' Output of this BoostedTreesMakeQuantileSummaries operation.
    pub fn summaries(&self) -> crate::Result<Vec<crate::Output>> {
        let mut Outputs = vec![];
        for i in 0..self.op.get_attr_int("num_features")? as i32 {
            Outputs.push(crate::Output {
                operation: self.op.clone(),
                index: i,
            });
        }
        Ok(Outputs)
    }
    /// Returns a Vector of float_values for 'float_values' Input of this BoostedTreesMakeQuantileSummaries operation.
    pub fn float_values(&self) -> crate::Result<Vec<crate::Input>> {
        let mut Inputs = vec![];
        for i in 0..self.op.get_attr_int("num_features")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
    /// Returns the 'example_weights' Input of this 'BoostedTreesMakeQuantileSummaries' operation.
    pub fn example_weights(&self) -> crate::Result<crate::Input> {
        let dynamic_offset = (self.op.get_attr_int("num_features")? + 1) as i32;
        Ok(crate::Input {
            operation: &self.op,
            index: dynamic_offset,
        })
    }
    /// Returns the 'epsilon' Input of this 'BoostedTreesMakeQuantileSummaries' operation.
    pub fn epsilon(&self) -> crate::Result<crate::Input> {
        let dynamic_offset = (self.op.get_attr_int("num_features")? + 2) as i32;
        Ok(crate::Input {
            operation: &self.op,
            index: dynamic_offset,
        })
    }
}
impl From<BoostedTreesMakeQuantileSummariesInst> for crate::Operation {
    fn from(inst: BoostedTreesMakeQuantileSummariesInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `BoostedTreesMakeQuantileSummaries::new().build(float_values, example_weights, epsilon, scope)`.
pub fn boosted_trees_make_quantile_summaries<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    float_values: O0,
    example_weights: O1,
    epsilon: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    BoostedTreesMakeQuantileSummaries::new().build(float_values, example_weights, epsilon, scope)
}

/// Builder for the `BoostedTreesMakeStatsSummary` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct BoostedTreesMakeStatsSummary {
    max_splits: ::std::option::Option<i64>,
    num_buckets: ::std::option::Option<i64>,
    num_features: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'BoostedTreesMakeStatsSummary' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct BoostedTreesMakeStatsSummaryInst {
    /// An instance of a fully built BoostedTreesMakeStatsSummary Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl BoostedTreesMakeStatsSummary {
    /// Creates a new `BoostedTreesMakeStatsSummary`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `max_splits` attribute.
    pub fn max_splits<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.max_splits = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `num_buckets` attribute.
    pub fn num_buckets<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.num_buckets = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `num_features` attribute.
    pub fn num_features<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.num_features = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `BoostedTreesMakeStatsSummary` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
    >(
        &self,
        node_ids: O0,
        gradients: O1,
        hessians: O2,
        bucketized_features_list: O3,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            node_ids.into(),
            gradients.into(),
            hessians.into(),
            bucketized_features_list.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        node_ids: crate::Output,
        gradients: crate::Output,
        hessians: crate::Output,
        bucketized_features_list: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("BoostedTreesMakeStatsSummary", |nd| {
            nd.add_input(node_ids);
            nd.add_input(gradients);
            nd.add_input(hessians);
            nd.add_input(bucketized_features_list);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.max_splits {
                nd.set_attr_int("max_splits", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_buckets {
                nd.set_attr_int("num_buckets", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_features {
                nd.set_attr_int("num_features", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'BoostedTreesMakeStatsSummary' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        node_ids: crate::Output,
        gradients: crate::Output,
        hessians: crate::Output,
        bucketized_features_list: Vec<crate::Output>,
        scope: &mut crate::Scope,
    ) -> crate::Result<BoostedTreesMakeStatsSummaryInst> {
        let op = scope.new_operation("BoostedTreesMakeStatsSummary", |builder| {
            builder.add_input(node_ids);
            builder.add_input(gradients);
            builder.add_input(hessians);
            builder.add_input_list(&bucketized_features_list);
            if let ::std::option::Option::Some(value) = &self.max_splits {
                builder.set_attr_int("max_splits", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_buckets {
                builder.set_attr_int("num_buckets", *value)?;
            }
            builder.set_attr_int(
                "num_features",
                bucketized_features_list.clone().len() as i64,
            )?;
            ::std::result::Result::Ok(())
        })?;
        Ok(BoostedTreesMakeStatsSummaryInst { op })
    }
}
impl BoostedTreesMakeStatsSummaryInst {
    /// Returns the 'stats_summary' Output of this 'BoostedTreesMakeStatsSummary' operation.
    pub fn stats_summary(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'node_ids' Input of this 'BoostedTreesMakeStatsSummary' operation.
    pub fn node_ids(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'gradients' Input of this 'BoostedTreesMakeStatsSummary' operation.
    pub fn gradients(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'hessians' Input of this 'BoostedTreesMakeStatsSummary' operation.
    pub fn hessians(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns a Vector of bucketized_features_list for 'bucketized_features_list' Input of this BoostedTreesMakeStatsSummary operation.
    pub fn bucketized_features_list(&self) -> crate::Result<Vec<crate::Input>> {
        let mut Inputs = vec![];
        for i in 3..self.op.get_attr_int("num_features")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
}
impl From<BoostedTreesMakeStatsSummaryInst> for crate::Operation {
    fn from(inst: BoostedTreesMakeStatsSummaryInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `BoostedTreesMakeStatsSummary::new().build(node_ids, gradients, hessians, bucketized_features_list, scope)`.
pub fn boosted_trees_make_stats_summary<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
>(
    node_ids: O0,
    gradients: O1,
    hessians: O2,
    bucketized_features_list: O3,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    BoostedTreesMakeStatsSummary::new().build(
        node_ids,
        gradients,
        hessians,
        bucketized_features_list,
        scope,
    )
}

/// Builder for the `BoostedTreesPredict` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct BoostedTreesPredict {
    num_bucketized_features: ::std::option::Option<i64>,
    logits_dimension: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'BoostedTreesPredict' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct BoostedTreesPredictInst {
    /// An instance of a fully built BoostedTreesPredict Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl BoostedTreesPredict {
    /// Creates a new `BoostedTreesPredict`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `num_bucketized_features` attribute.
    pub fn num_bucketized_features<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.num_bucketized_features = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `logits_dimension` attribute.
    pub fn logits_dimension<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.logits_dimension = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `BoostedTreesPredict` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        tree_ensemble_handle: O0,
        bucketized_features: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            tree_ensemble_handle.into(),
            bucketized_features.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        tree_ensemble_handle: crate::Output,
        bucketized_features: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("BoostedTreesPredict", |nd| {
            nd.add_input(tree_ensemble_handle);
            nd.add_input(bucketized_features);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.num_bucketized_features {
                nd.set_attr_int("num_bucketized_features", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.logits_dimension {
                nd.set_attr_int("logits_dimension", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'BoostedTreesPredict' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        tree_ensemble_handle: crate::Output,
        bucketized_features: Vec<crate::Output>,
        scope: &mut crate::Scope,
    ) -> crate::Result<BoostedTreesPredictInst> {
        let op = scope.new_operation("BoostedTreesPredict", |builder| {
            builder.add_input(tree_ensemble_handle);
            builder.add_input_list(&bucketized_features);
            builder.set_attr_int(
                "num_bucketized_features",
                bucketized_features.clone().len() as i64,
            )?;
            if let ::std::option::Option::Some(value) = &self.logits_dimension {
                builder.set_attr_int("logits_dimension", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(BoostedTreesPredictInst { op })
    }
}
impl BoostedTreesPredictInst {
    /// Returns the 'logits' Output of this 'BoostedTreesPredict' operation.
    pub fn logits(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'tree_ensemble_handle' Input of this 'BoostedTreesPredict' operation.
    pub fn tree_ensemble_handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns a Vector of bucketized_features for 'bucketized_features' Input of this BoostedTreesPredict operation.
    pub fn bucketized_features(&self) -> crate::Result<Vec<crate::Input>> {
        let mut Inputs = vec![];
        for i in 1..self.op.get_attr_int("num_bucketized_features")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
}
impl From<BoostedTreesPredictInst> for crate::Operation {
    fn from(inst: BoostedTreesPredictInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `BoostedTreesPredict::new().build(tree_ensemble_handle, bucketized_features, scope)`.
pub fn boosted_trees_predict<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    tree_ensemble_handle: O0,
    bucketized_features: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    BoostedTreesPredict::new().build(tree_ensemble_handle, bucketized_features, scope)
}

/// Builder for the `BoostedTreesQuantileStreamResourceAddSummaries` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct BoostedTreesQuantileStreamResourceAddSummaries {
    num_features: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'BoostedTreesQuantileStreamResourceAddSummaries' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct BoostedTreesQuantileStreamResourceAddSummariesInst {
    /// An instance of a fully built BoostedTreesQuantileStreamResourceAddSummaries Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl BoostedTreesQuantileStreamResourceAddSummaries {
    /// Creates a new `BoostedTreesQuantileStreamResourceAddSummaries`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `num_features` attribute.
    pub fn num_features<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.num_features = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `BoostedTreesQuantileStreamResourceAddSummaries` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        quantile_stream_resource_handle: O0,
        summaries: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            quantile_stream_resource_handle.into(),
            summaries.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        quantile_stream_resource_handle: crate::Output,
        summaries: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("BoostedTreesQuantileStreamResourceAddSummaries", |nd| {
            nd.add_input(quantile_stream_resource_handle);
            nd.add_input(summaries);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.num_features {
                nd.set_attr_int("num_features", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'BoostedTreesQuantileStreamResourceAddSummaries' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        quantile_stream_resource_handle: crate::Output,
        summaries: Vec<crate::Output>,
        scope: &mut crate::Scope,
    ) -> crate::Result<BoostedTreesQuantileStreamResourceAddSummariesInst> {
        let op = scope.new_operation(
            "BoostedTreesQuantileStreamResourceAddSummaries",
            |builder| {
                builder.add_input(quantile_stream_resource_handle);
                builder.add_input_list(&summaries);
                builder.set_attr_int("num_features", summaries.clone().len() as i64)?;
                ::std::result::Result::Ok(())
            },
        )?;
        Ok(BoostedTreesQuantileStreamResourceAddSummariesInst { op })
    }
}
impl BoostedTreesQuantileStreamResourceAddSummariesInst {
    /// Returns the 'quantile_stream_resource_handle' Input of this 'BoostedTreesQuantileStreamResourceAddSummaries' operation.
    pub fn quantile_stream_resource_handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns a Vector of summaries for 'summaries' Input of this BoostedTreesQuantileStreamResourceAddSummaries operation.
    pub fn summaries(&self) -> crate::Result<Vec<crate::Input>> {
        let mut Inputs = vec![];
        for i in 1..self.op.get_attr_int("num_features")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
}
impl From<BoostedTreesQuantileStreamResourceAddSummariesInst> for crate::Operation {
    fn from(inst: BoostedTreesQuantileStreamResourceAddSummariesInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `BoostedTreesQuantileStreamResourceAddSummaries::new().build(quantile_stream_resource_handle, summaries, scope)`.
pub fn boosted_trees_quantile_stream_resource_add_summaries<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    quantile_stream_resource_handle: O0,
    summaries: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    BoostedTreesQuantileStreamResourceAddSummaries::new().build(
        quantile_stream_resource_handle,
        summaries,
        scope,
    )
}

/// Builder for the `BoostedTreesQuantileStreamResourceDeserialize` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct BoostedTreesQuantileStreamResourceDeserialize {
    num_streams: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'BoostedTreesQuantileStreamResourceDeserialize' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct BoostedTreesQuantileStreamResourceDeserializeInst {
    /// An instance of a fully built BoostedTreesQuantileStreamResourceDeserialize Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl BoostedTreesQuantileStreamResourceDeserialize {
    /// Creates a new `BoostedTreesQuantileStreamResourceDeserialize`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `num_streams` attribute.
    pub fn num_streams<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.num_streams = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `BoostedTreesQuantileStreamResourceDeserialize` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        quantile_stream_resource_handle: O0,
        bucket_boundaries: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            quantile_stream_resource_handle.into(),
            bucket_boundaries.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        quantile_stream_resource_handle: crate::Output,
        bucket_boundaries: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("BoostedTreesQuantileStreamResourceDeserialize", |nd| {
            nd.add_input(quantile_stream_resource_handle);
            nd.add_input(bucket_boundaries);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.num_streams {
                nd.set_attr_int("num_streams", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'BoostedTreesQuantileStreamResourceDeserialize' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        quantile_stream_resource_handle: crate::Output,
        bucket_boundaries: Vec<crate::Output>,
        scope: &mut crate::Scope,
    ) -> crate::Result<BoostedTreesQuantileStreamResourceDeserializeInst> {
        let op =
            scope.new_operation("BoostedTreesQuantileStreamResourceDeserialize", |builder| {
                builder.add_input(quantile_stream_resource_handle);
                builder.add_input_list(&bucket_boundaries);
                builder.set_attr_int("num_streams", bucket_boundaries.clone().len() as i64)?;
                ::std::result::Result::Ok(())
            })?;
        Ok(BoostedTreesQuantileStreamResourceDeserializeInst { op })
    }
}
impl BoostedTreesQuantileStreamResourceDeserializeInst {
    /// Returns the 'quantile_stream_resource_handle' Input of this 'BoostedTreesQuantileStreamResourceDeserialize' operation.
    pub fn quantile_stream_resource_handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns a Vector of bucket_boundaries for 'bucket_boundaries' Input of this BoostedTreesQuantileStreamResourceDeserialize operation.
    pub fn bucket_boundaries(&self) -> crate::Result<Vec<crate::Input>> {
        let mut Inputs = vec![];
        for i in 1..self.op.get_attr_int("num_streams")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
}
impl From<BoostedTreesQuantileStreamResourceDeserializeInst> for crate::Operation {
    fn from(inst: BoostedTreesQuantileStreamResourceDeserializeInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `BoostedTreesQuantileStreamResourceDeserialize::new().build(quantile_stream_resource_handle, bucket_boundaries, scope)`.
pub fn boosted_trees_quantile_stream_resource_deserialize<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    quantile_stream_resource_handle: O0,
    bucket_boundaries: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    BoostedTreesQuantileStreamResourceDeserialize::new().build(
        quantile_stream_resource_handle,
        bucket_boundaries,
        scope,
    )
}

/// Builder for the `BoostedTreesQuantileStreamResourceFlush` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct BoostedTreesQuantileStreamResourceFlush {
    generate_quantiles: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'BoostedTreesQuantileStreamResourceFlush' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct BoostedTreesQuantileStreamResourceFlushInst {
    /// An instance of a fully built BoostedTreesQuantileStreamResourceFlush Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl BoostedTreesQuantileStreamResourceFlush {
    /// Creates a new `BoostedTreesQuantileStreamResourceFlush`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `generate_quantiles` attribute.
    pub fn generate_quantiles<ArgType: ::std::convert::Into<bool>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.generate_quantiles = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `BoostedTreesQuantileStreamResourceFlush` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        quantile_stream_resource_handle: O0,
        num_buckets: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            quantile_stream_resource_handle.into(),
            num_buckets.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        quantile_stream_resource_handle: crate::Output,
        num_buckets: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("BoostedTreesQuantileStreamResourceFlush", |nd| {
            nd.add_input(quantile_stream_resource_handle);
            nd.add_input(num_buckets);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.generate_quantiles {
                nd.set_attr_bool("generate_quantiles", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'BoostedTreesQuantileStreamResourceFlush' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        quantile_stream_resource_handle: crate::Output,
        num_buckets: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<BoostedTreesQuantileStreamResourceFlushInst> {
        let op = scope.new_operation("BoostedTreesQuantileStreamResourceFlush", |builder| {
            builder.add_input(quantile_stream_resource_handle);
            builder.add_input(num_buckets);
            if let ::std::option::Option::Some(value) = &self.generate_quantiles {
                builder.set_attr_bool("generate_quantiles", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(BoostedTreesQuantileStreamResourceFlushInst { op })
    }
}
impl BoostedTreesQuantileStreamResourceFlushInst {
    /// Returns the 'quantile_stream_resource_handle' Input of this 'BoostedTreesQuantileStreamResourceFlush' operation.
    pub fn quantile_stream_resource_handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'num_buckets' Input of this 'BoostedTreesQuantileStreamResourceFlush' operation.
    pub fn num_buckets(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<BoostedTreesQuantileStreamResourceFlushInst> for crate::Operation {
    fn from(inst: BoostedTreesQuantileStreamResourceFlushInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `BoostedTreesQuantileStreamResourceFlush::new().build(quantile_stream_resource_handle, num_buckets, scope)`.
pub fn boosted_trees_quantile_stream_resource_flush<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    quantile_stream_resource_handle: O0,
    num_buckets: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    BoostedTreesQuantileStreamResourceFlush::new().build(
        quantile_stream_resource_handle,
        num_buckets,
        scope,
    )
}

/// Builder for the `BoostedTreesQuantileStreamResourceGetBucketBoundaries` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct BoostedTreesQuantileStreamResourceGetBucketBoundaries {
    num_features: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'BoostedTreesQuantileStreamResourceGetBucketBoundaries' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct BoostedTreesQuantileStreamResourceGetBucketBoundariesInst {
    /// An instance of a fully built BoostedTreesQuantileStreamResourceGetBucketBoundaries Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl BoostedTreesQuantileStreamResourceGetBucketBoundaries {
    /// Creates a new `BoostedTreesQuantileStreamResourceGetBucketBoundaries`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `num_features` attribute.
    pub fn num_features<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.num_features = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `BoostedTreesQuantileStreamResourceGetBucketBoundaries` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        quantile_stream_resource_handle: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(quantile_stream_resource_handle.into(), scope)
    }
    fn build_impl(
        &self,
        quantile_stream_resource_handle: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation(
            "BoostedTreesQuantileStreamResourceGetBucketBoundaries",
            |nd| {
                nd.add_input(quantile_stream_resource_handle);
                for op in &self.control_inputs {
                    nd.add_control_input(op);
                }
                if let ::std::option::Option::Some(value) = &self.num_features {
                    nd.set_attr_int("num_features", *value)?;
                }
                ::std::result::Result::Ok(())
            },
        )
    }

    /// Builds a new instance of 'BoostedTreesQuantileStreamResourceGetBucketBoundaries' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        quantile_stream_resource_handle: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<BoostedTreesQuantileStreamResourceGetBucketBoundariesInst> {
        let op = scope.new_operation(
            "BoostedTreesQuantileStreamResourceGetBucketBoundaries",
            |builder| {
                builder.add_input(quantile_stream_resource_handle);
                if let ::std::option::Option::Some(value) = &self.num_features {
                    builder.set_attr_int("num_features", *value)?;
                }
                ::std::result::Result::Ok(())
            },
        )?;
        Ok(BoostedTreesQuantileStreamResourceGetBucketBoundariesInst { op })
    }
}
impl BoostedTreesQuantileStreamResourceGetBucketBoundariesInst {
    /// Returns a Vector of bucket_boundaries for 'bucket_boundaries' Output of this BoostedTreesQuantileStreamResourceGetBucketBoundaries operation.
    pub fn bucket_boundaries(&self) -> crate::Result<Vec<crate::Output>> {
        let mut Outputs = vec![];
        for i in 0..self.op.get_attr_int("num_features")? as i32 {
            Outputs.push(crate::Output {
                operation: self.op.clone(),
                index: i,
            });
        }
        Ok(Outputs)
    }
    /// Returns the 'quantile_stream_resource_handle' Input of this 'BoostedTreesQuantileStreamResourceGetBucketBoundaries' operation.
    pub fn quantile_stream_resource_handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<BoostedTreesQuantileStreamResourceGetBucketBoundariesInst> for crate::Operation {
    fn from(inst: BoostedTreesQuantileStreamResourceGetBucketBoundariesInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `BoostedTreesQuantileStreamResourceGetBucketBoundaries::new().build(quantile_stream_resource_handle, scope)`.
pub fn boosted_trees_quantile_stream_resource_get_bucket_boundaries<
    O0: ::std::convert::Into<crate::Output>,
>(
    quantile_stream_resource_handle: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    BoostedTreesQuantileStreamResourceGetBucketBoundaries::new()
        .build(quantile_stream_resource_handle, scope)
}

/// Builder for the `BoostedTreesQuantileStreamResourceHandleOp` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct BoostedTreesQuantileStreamResourceHandleOp {
    container: ::std::option::Option<::std::string::String>,
    shared_name: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'BoostedTreesQuantileStreamResourceHandleOp' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct BoostedTreesQuantileStreamResourceHandleOpInst {
    /// An instance of a fully built BoostedTreesQuantileStreamResourceHandleOp Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl BoostedTreesQuantileStreamResourceHandleOp {
    /// Creates a new `BoostedTreesQuantileStreamResourceHandleOp`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `container` attribute.
    pub fn container<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.container = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shared_name` attribute.
    pub fn shared_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.shared_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `BoostedTreesQuantileStreamResourceHandleOp` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("BoostedTreesQuantileStreamResourceHandleOp", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.container {
                nd.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                nd.set_attr_string("shared_name", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'BoostedTreesQuantileStreamResourceHandleOp' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        scope: &mut crate::Scope,
    ) -> crate::Result<BoostedTreesQuantileStreamResourceHandleOpInst> {
        let op = scope.new_operation("BoostedTreesQuantileStreamResourceHandleOp", |builder| {
            if let ::std::option::Option::Some(value) = &self.container {
                builder.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                builder.set_attr_string("shared_name", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(BoostedTreesQuantileStreamResourceHandleOpInst { op })
    }
}
impl BoostedTreesQuantileStreamResourceHandleOpInst {
    /// Returns the 'resource' Output of this 'BoostedTreesQuantileStreamResourceHandleOp' operation.
    pub fn resource(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
}
impl From<BoostedTreesQuantileStreamResourceHandleOpInst> for crate::Operation {
    fn from(inst: BoostedTreesQuantileStreamResourceHandleOpInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `BoostedTreesQuantileStreamResourceHandleOp::new().build(scope)`.
pub fn boosted_trees_quantile_stream_resource_handle_op(
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    BoostedTreesQuantileStreamResourceHandleOp::new().build(scope)
}

/// Builder for the `BoostedTreesSerializeEnsemble` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct BoostedTreesSerializeEnsemble {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'BoostedTreesSerializeEnsemble' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct BoostedTreesSerializeEnsembleInst {
    /// An instance of a fully built BoostedTreesSerializeEnsemble Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl BoostedTreesSerializeEnsemble {
    /// Creates a new `BoostedTreesSerializeEnsemble`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `BoostedTreesSerializeEnsemble` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        tree_ensemble_handle: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(tree_ensemble_handle.into(), scope)
    }
    fn build_impl(
        &self,
        tree_ensemble_handle: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("BoostedTreesSerializeEnsemble", |nd| {
            nd.add_input(tree_ensemble_handle);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'BoostedTreesSerializeEnsemble' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        tree_ensemble_handle: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<BoostedTreesSerializeEnsembleInst> {
        let op = scope.new_operation("BoostedTreesSerializeEnsemble", |builder| {
            builder.add_input(tree_ensemble_handle);
            ::std::result::Result::Ok(())
        })?;
        Ok(BoostedTreesSerializeEnsembleInst { op })
    }
}
impl BoostedTreesSerializeEnsembleInst {
    /// Returns the 'stamp_token' Output of this 'BoostedTreesSerializeEnsemble' operation.
    pub fn stamp_token(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'tree_ensemble_serialized' Output of this 'BoostedTreesSerializeEnsemble' operation.
    pub fn tree_ensemble_serialized(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'tree_ensemble_handle' Input of this 'BoostedTreesSerializeEnsemble' operation.
    pub fn tree_ensemble_handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<BoostedTreesSerializeEnsembleInst> for crate::Operation {
    fn from(inst: BoostedTreesSerializeEnsembleInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `BoostedTreesSerializeEnsemble::new().build(tree_ensemble_handle, scope)`.
pub fn boosted_trees_serialize_ensemble<O0: ::std::convert::Into<crate::Output>>(
    tree_ensemble_handle: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    BoostedTreesSerializeEnsemble::new().build(tree_ensemble_handle, scope)
}

/// Builder for the `BoostedTreesSparseAggregateStats` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct BoostedTreesSparseAggregateStats {
    max_splits: ::std::option::Option<i64>,
    num_buckets: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'BoostedTreesSparseAggregateStats' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct BoostedTreesSparseAggregateStatsInst {
    /// An instance of a fully built BoostedTreesSparseAggregateStats Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl BoostedTreesSparseAggregateStats {
    /// Creates a new `BoostedTreesSparseAggregateStats`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `max_splits` attribute.
    pub fn max_splits<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.max_splits = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `num_buckets` attribute.
    pub fn num_buckets<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.num_buckets = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `BoostedTreesSparseAggregateStats` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
    >(
        &self,
        node_ids: O0,
        gradients: O1,
        hessians: O2,
        feature_indices: O3,
        feature_values: O4,
        feature_shape: O5,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            node_ids.into(),
            gradients.into(),
            hessians.into(),
            feature_indices.into(),
            feature_values.into(),
            feature_shape.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        node_ids: crate::Output,
        gradients: crate::Output,
        hessians: crate::Output,
        feature_indices: crate::Output,
        feature_values: crate::Output,
        feature_shape: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("BoostedTreesSparseAggregateStats", |nd| {
            nd.add_input(node_ids);
            nd.add_input(gradients);
            nd.add_input(hessians);
            nd.add_input(feature_indices);
            nd.add_input(feature_values);
            nd.add_input(feature_shape);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.max_splits {
                nd.set_attr_int("max_splits", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_buckets {
                nd.set_attr_int("num_buckets", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'BoostedTreesSparseAggregateStats' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        node_ids: crate::Output,
        gradients: crate::Output,
        hessians: crate::Output,
        feature_indices: crate::Output,
        feature_values: crate::Output,
        feature_shape: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<BoostedTreesSparseAggregateStatsInst> {
        let op = scope.new_operation("BoostedTreesSparseAggregateStats", |builder| {
            builder.add_input(node_ids);
            builder.add_input(gradients);
            builder.add_input(hessians);
            builder.add_input(feature_indices);
            builder.add_input(feature_values);
            builder.add_input(feature_shape);
            if let ::std::option::Option::Some(value) = &self.max_splits {
                builder.set_attr_int("max_splits", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_buckets {
                builder.set_attr_int("num_buckets", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(BoostedTreesSparseAggregateStatsInst { op })
    }
}
impl BoostedTreesSparseAggregateStatsInst {
    /// Returns the 'stats_summary_indices' Output of this 'BoostedTreesSparseAggregateStats' operation.
    pub fn stats_summary_indices(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'stats_summary_values' Output of this 'BoostedTreesSparseAggregateStats' operation.
    pub fn stats_summary_values(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'stats_summary_shape' Output of this 'BoostedTreesSparseAggregateStats' operation.
    pub fn stats_summary_shape(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns the 'node_ids' Input of this 'BoostedTreesSparseAggregateStats' operation.
    pub fn node_ids(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'gradients' Input of this 'BoostedTreesSparseAggregateStats' operation.
    pub fn gradients(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'hessians' Input of this 'BoostedTreesSparseAggregateStats' operation.
    pub fn hessians(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'feature_indices' Input of this 'BoostedTreesSparseAggregateStats' operation.
    pub fn feature_indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'feature_values' Input of this 'BoostedTreesSparseAggregateStats' operation.
    pub fn feature_values(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
    /// Returns the 'feature_shape' Input of this 'BoostedTreesSparseAggregateStats' operation.
    pub fn feature_shape(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 5,
        }
    }
}
impl From<BoostedTreesSparseAggregateStatsInst> for crate::Operation {
    fn from(inst: BoostedTreesSparseAggregateStatsInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `BoostedTreesSparseAggregateStats::new().build(node_ids, gradients, hessians, feature_indices, feature_values, feature_shape, scope)`.
pub fn boosted_trees_sparse_aggregate_stats<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
>(
    node_ids: O0,
    gradients: O1,
    hessians: O2,
    feature_indices: O3,
    feature_values: O4,
    feature_shape: O5,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    BoostedTreesSparseAggregateStats::new().build(
        node_ids,
        gradients,
        hessians,
        feature_indices,
        feature_values,
        feature_shape,
        scope,
    )
}

/// Builder for the `BoostedTreesSparseCalculateBestFeatureSplit` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct BoostedTreesSparseCalculateBestFeatureSplit {
    logits_dimension: ::std::option::Option<i64>,
    split_type: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'BoostedTreesSparseCalculateBestFeatureSplit' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct BoostedTreesSparseCalculateBestFeatureSplitInst {
    /// An instance of a fully built BoostedTreesSparseCalculateBestFeatureSplit Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl BoostedTreesSparseCalculateBestFeatureSplit {
    /// Creates a new `BoostedTreesSparseCalculateBestFeatureSplit`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `logits_dimension` attribute.
    pub fn logits_dimension<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.logits_dimension = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `split_type` attribute.
    pub fn split_type<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.split_type = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `BoostedTreesSparseCalculateBestFeatureSplit` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
        O6: ::std::convert::Into<crate::Output>,
        O7: ::std::convert::Into<crate::Output>,
    >(
        &self,
        node_id_range: O0,
        stats_summary_indices: O1,
        stats_summary_values: O2,
        stats_summary_shape: O3,
        l1: O4,
        l2: O5,
        tree_complexity: O6,
        min_node_weight: O7,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            node_id_range.into(),
            stats_summary_indices.into(),
            stats_summary_values.into(),
            stats_summary_shape.into(),
            l1.into(),
            l2.into(),
            tree_complexity.into(),
            min_node_weight.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        node_id_range: crate::Output,
        stats_summary_indices: crate::Output,
        stats_summary_values: crate::Output,
        stats_summary_shape: crate::Output,
        l1: crate::Output,
        l2: crate::Output,
        tree_complexity: crate::Output,
        min_node_weight: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("BoostedTreesSparseCalculateBestFeatureSplit", |nd| {
            nd.add_input(node_id_range);
            nd.add_input(stats_summary_indices);
            nd.add_input(stats_summary_values);
            nd.add_input(stats_summary_shape);
            nd.add_input(l1);
            nd.add_input(l2);
            nd.add_input(tree_complexity);
            nd.add_input(min_node_weight);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.logits_dimension {
                nd.set_attr_int("logits_dimension", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.split_type {
                nd.set_attr_string("split_type", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'BoostedTreesSparseCalculateBestFeatureSplit' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        node_id_range: crate::Output,
        stats_summary_indices: crate::Output,
        stats_summary_values: crate::Output,
        stats_summary_shape: crate::Output,
        l1: crate::Output,
        l2: crate::Output,
        tree_complexity: crate::Output,
        min_node_weight: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<BoostedTreesSparseCalculateBestFeatureSplitInst> {
        let op = scope.new_operation("BoostedTreesSparseCalculateBestFeatureSplit", |builder| {
            builder.add_input(node_id_range);
            builder.add_input(stats_summary_indices);
            builder.add_input(stats_summary_values);
            builder.add_input(stats_summary_shape);
            builder.add_input(l1);
            builder.add_input(l2);
            builder.add_input(tree_complexity);
            builder.add_input(min_node_weight);
            if let ::std::option::Option::Some(value) = &self.logits_dimension {
                builder.set_attr_int("logits_dimension", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.split_type {
                builder.set_attr_string("split_type", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(BoostedTreesSparseCalculateBestFeatureSplitInst { op })
    }
}
impl BoostedTreesSparseCalculateBestFeatureSplitInst {
    /// Returns the 'node_ids' Output of this 'BoostedTreesSparseCalculateBestFeatureSplit' operation.
    pub fn node_ids(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'gains' Output of this 'BoostedTreesSparseCalculateBestFeatureSplit' operation.
    pub fn gains(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'feature_dimensions' Output of this 'BoostedTreesSparseCalculateBestFeatureSplit' operation.
    pub fn feature_dimensions(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns the 'thresholds' Output of this 'BoostedTreesSparseCalculateBestFeatureSplit' operation.
    pub fn thresholds(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 3,
        }
    }
    /// Returns the 'left_node_contribs' Output of this 'BoostedTreesSparseCalculateBestFeatureSplit' operation.
    pub fn left_node_contribs(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 4,
        }
    }
    /// Returns the 'right_node_contribs' Output of this 'BoostedTreesSparseCalculateBestFeatureSplit' operation.
    pub fn right_node_contribs(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 5,
        }
    }
    /// Returns the 'split_with_default_directions' Output of this 'BoostedTreesSparseCalculateBestFeatureSplit' operation.
    pub fn split_with_default_directions(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 6,
        }
    }
    /// Returns the 'node_id_range' Input of this 'BoostedTreesSparseCalculateBestFeatureSplit' operation.
    pub fn node_id_range(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'stats_summary_indices' Input of this 'BoostedTreesSparseCalculateBestFeatureSplit' operation.
    pub fn stats_summary_indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'stats_summary_values' Input of this 'BoostedTreesSparseCalculateBestFeatureSplit' operation.
    pub fn stats_summary_values(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'stats_summary_shape' Input of this 'BoostedTreesSparseCalculateBestFeatureSplit' operation.
    pub fn stats_summary_shape(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'l1' Input of this 'BoostedTreesSparseCalculateBestFeatureSplit' operation.
    pub fn l1(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
    /// Returns the 'l2' Input of this 'BoostedTreesSparseCalculateBestFeatureSplit' operation.
    pub fn l2(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 5,
        }
    }
    /// Returns the 'tree_complexity' Input of this 'BoostedTreesSparseCalculateBestFeatureSplit' operation.
    pub fn tree_complexity(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 6,
        }
    }
    /// Returns the 'min_node_weight' Input of this 'BoostedTreesSparseCalculateBestFeatureSplit' operation.
    pub fn min_node_weight(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 7,
        }
    }
}
impl From<BoostedTreesSparseCalculateBestFeatureSplitInst> for crate::Operation {
    fn from(inst: BoostedTreesSparseCalculateBestFeatureSplitInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `BoostedTreesSparseCalculateBestFeatureSplit::new().build(node_id_range, stats_summary_indices, stats_summary_values, stats_summary_shape, l1, l2, tree_complexity, min_node_weight, scope)`.
pub fn boosted_trees_sparse_calculate_best_feature_split<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
    O6: ::std::convert::Into<crate::Output>,
    O7: ::std::convert::Into<crate::Output>,
>(
    node_id_range: O0,
    stats_summary_indices: O1,
    stats_summary_values: O2,
    stats_summary_shape: O3,
    l1: O4,
    l2: O5,
    tree_complexity: O6,
    min_node_weight: O7,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    BoostedTreesSparseCalculateBestFeatureSplit::new().build(
        node_id_range,
        stats_summary_indices,
        stats_summary_values,
        stats_summary_shape,
        l1,
        l2,
        tree_complexity,
        min_node_weight,
        scope,
    )
}

/// Builder for the `BoostedTreesTrainingPredict` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct BoostedTreesTrainingPredict {
    num_bucketized_features: ::std::option::Option<i64>,
    logits_dimension: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'BoostedTreesTrainingPredict' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct BoostedTreesTrainingPredictInst {
    /// An instance of a fully built BoostedTreesTrainingPredict Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl BoostedTreesTrainingPredict {
    /// Creates a new `BoostedTreesTrainingPredict`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `num_bucketized_features` attribute.
    pub fn num_bucketized_features<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.num_bucketized_features = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `logits_dimension` attribute.
    pub fn logits_dimension<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.logits_dimension = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `BoostedTreesTrainingPredict` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
    >(
        &self,
        tree_ensemble_handle: O0,
        cached_tree_ids: O1,
        cached_node_ids: O2,
        bucketized_features: O3,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            tree_ensemble_handle.into(),
            cached_tree_ids.into(),
            cached_node_ids.into(),
            bucketized_features.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        tree_ensemble_handle: crate::Output,
        cached_tree_ids: crate::Output,
        cached_node_ids: crate::Output,
        bucketized_features: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("BoostedTreesTrainingPredict", |nd| {
            nd.add_input(tree_ensemble_handle);
            nd.add_input(cached_tree_ids);
            nd.add_input(cached_node_ids);
            nd.add_input(bucketized_features);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.num_bucketized_features {
                nd.set_attr_int("num_bucketized_features", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.logits_dimension {
                nd.set_attr_int("logits_dimension", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'BoostedTreesTrainingPredict' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        tree_ensemble_handle: crate::Output,
        cached_tree_ids: crate::Output,
        cached_node_ids: crate::Output,
        bucketized_features: Vec<crate::Output>,
        scope: &mut crate::Scope,
    ) -> crate::Result<BoostedTreesTrainingPredictInst> {
        let op = scope.new_operation("BoostedTreesTrainingPredict", |builder| {
            builder.add_input(tree_ensemble_handle);
            builder.add_input(cached_tree_ids);
            builder.add_input(cached_node_ids);
            builder.add_input_list(&bucketized_features);
            builder.set_attr_int(
                "num_bucketized_features",
                bucketized_features.clone().len() as i64,
            )?;
            if let ::std::option::Option::Some(value) = &self.logits_dimension {
                builder.set_attr_int("logits_dimension", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(BoostedTreesTrainingPredictInst { op })
    }
}
impl BoostedTreesTrainingPredictInst {
    /// Returns the 'partial_logits' Output of this 'BoostedTreesTrainingPredict' operation.
    pub fn partial_logits(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'tree_ids' Output of this 'BoostedTreesTrainingPredict' operation.
    pub fn tree_ids(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'node_ids' Output of this 'BoostedTreesTrainingPredict' operation.
    pub fn node_ids(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns the 'tree_ensemble_handle' Input of this 'BoostedTreesTrainingPredict' operation.
    pub fn tree_ensemble_handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'cached_tree_ids' Input of this 'BoostedTreesTrainingPredict' operation.
    pub fn cached_tree_ids(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'cached_node_ids' Input of this 'BoostedTreesTrainingPredict' operation.
    pub fn cached_node_ids(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns a Vector of bucketized_features for 'bucketized_features' Input of this BoostedTreesTrainingPredict operation.
    pub fn bucketized_features(&self) -> crate::Result<Vec<crate::Input>> {
        let mut Inputs = vec![];
        for i in 3..self.op.get_attr_int("num_bucketized_features")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
}
impl From<BoostedTreesTrainingPredictInst> for crate::Operation {
    fn from(inst: BoostedTreesTrainingPredictInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `BoostedTreesTrainingPredict::new().build(tree_ensemble_handle, cached_tree_ids, cached_node_ids, bucketized_features, scope)`.
pub fn boosted_trees_training_predict<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
>(
    tree_ensemble_handle: O0,
    cached_tree_ids: O1,
    cached_node_ids: O2,
    bucketized_features: O3,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    BoostedTreesTrainingPredict::new().build(
        tree_ensemble_handle,
        cached_tree_ids,
        cached_node_ids,
        bucketized_features,
        scope,
    )
}

/// Builder for the `BoostedTreesUpdateEnsemble` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct BoostedTreesUpdateEnsemble {
    pruning_mode: ::std::option::Option<i64>,
    num_features: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'BoostedTreesUpdateEnsemble' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct BoostedTreesUpdateEnsembleInst {
    /// An instance of a fully built BoostedTreesUpdateEnsemble Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl BoostedTreesUpdateEnsemble {
    /// Creates a new `BoostedTreesUpdateEnsemble`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `pruning_mode` attribute.
    pub fn pruning_mode<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.pruning_mode = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `num_features` attribute.
    pub fn num_features<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.num_features = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `BoostedTreesUpdateEnsemble` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
        O6: ::std::convert::Into<crate::Output>,
        O7: ::std::convert::Into<crate::Output>,
        O8: ::std::convert::Into<crate::Output>,
    >(
        &self,
        tree_ensemble_handle: O0,
        feature_ids: O1,
        node_ids: O2,
        gains: O3,
        thresholds: O4,
        left_node_contribs: O5,
        right_node_contribs: O6,
        max_depth: O7,
        learning_rate: O8,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            tree_ensemble_handle.into(),
            feature_ids.into(),
            node_ids.into(),
            gains.into(),
            thresholds.into(),
            left_node_contribs.into(),
            right_node_contribs.into(),
            max_depth.into(),
            learning_rate.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        tree_ensemble_handle: crate::Output,
        feature_ids: crate::Output,
        node_ids: crate::Output,
        gains: crate::Output,
        thresholds: crate::Output,
        left_node_contribs: crate::Output,
        right_node_contribs: crate::Output,
        max_depth: crate::Output,
        learning_rate: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("BoostedTreesUpdateEnsemble", |nd| {
            nd.add_input(tree_ensemble_handle);
            nd.add_input(feature_ids);
            nd.add_input(node_ids);
            nd.add_input(gains);
            nd.add_input(thresholds);
            nd.add_input(left_node_contribs);
            nd.add_input(right_node_contribs);
            nd.add_input(max_depth);
            nd.add_input(learning_rate);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.pruning_mode {
                nd.set_attr_int("pruning_mode", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_features {
                nd.set_attr_int("num_features", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'BoostedTreesUpdateEnsemble' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        tree_ensemble_handle: crate::Output,
        feature_ids: crate::Output,
        node_ids: Vec<crate::Output>,
        gains: Vec<crate::Output>,
        thresholds: Vec<crate::Output>,
        left_node_contribs: Vec<crate::Output>,
        right_node_contribs: Vec<crate::Output>,
        max_depth: crate::Output,
        learning_rate: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<BoostedTreesUpdateEnsembleInst> {
        let op = scope.new_operation("BoostedTreesUpdateEnsemble", |builder| {
            builder.add_input(tree_ensemble_handle);
            builder.add_input(feature_ids);
            builder.add_input_list(&node_ids);
            builder.add_input_list(&gains);
            builder.add_input_list(&thresholds);
            builder.add_input_list(&left_node_contribs);
            builder.add_input_list(&right_node_contribs);
            builder.add_input(max_depth);
            builder.add_input(learning_rate);
            if let ::std::option::Option::Some(value) = &self.pruning_mode {
                builder.set_attr_int("pruning_mode", *value)?;
            }
            builder.set_attr_int("num_features", node_ids.clone().len() as i64)?;
            ::std::result::Result::Ok(())
        })?;
        Ok(BoostedTreesUpdateEnsembleInst { op })
    }
}
impl BoostedTreesUpdateEnsembleInst {
    /// Returns the 'tree_ensemble_handle' Input of this 'BoostedTreesUpdateEnsemble' operation.
    pub fn tree_ensemble_handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'feature_ids' Input of this 'BoostedTreesUpdateEnsemble' operation.
    pub fn feature_ids(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns a Vector of node_ids for 'node_ids' Input of this BoostedTreesUpdateEnsemble operation.
    pub fn node_ids(&self) -> crate::Result<Vec<crate::Input>> {
        let mut Inputs = vec![];
        for i in 2..self.op.get_attr_int("num_features")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
    /// Returns a Vector of gains for 'gains' Input of this BoostedTreesUpdateEnsemble operation.
    pub fn gains(&self) -> crate::Result<Vec<crate::Input>> {
        let dynamic_offset = (self.op.get_attr_int("num_features")? + 3) as i32;
        let mut Inputs = vec![];
        for i in dynamic_offset..dynamic_offset + self.op.get_attr_int("num_features")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
    /// Returns a Vector of thresholds for 'thresholds' Input of this BoostedTreesUpdateEnsemble operation.
    pub fn thresholds(&self) -> crate::Result<Vec<crate::Input>> {
        let dynamic_offset = (2 * self.op.get_attr_int("num_features")? + 4) as i32;
        let mut Inputs = vec![];
        for i in dynamic_offset..dynamic_offset + self.op.get_attr_int("num_features")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
    /// Returns a Vector of left_node_contribs for 'left_node_contribs' Input of this BoostedTreesUpdateEnsemble operation.
    pub fn left_node_contribs(&self) -> crate::Result<Vec<crate::Input>> {
        let dynamic_offset = (3 * self.op.get_attr_int("num_features")? + 5) as i32;
        let mut Inputs = vec![];
        for i in dynamic_offset..dynamic_offset + self.op.get_attr_int("num_features")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
    /// Returns a Vector of right_node_contribs for 'right_node_contribs' Input of this BoostedTreesUpdateEnsemble operation.
    pub fn right_node_contribs(&self) -> crate::Result<Vec<crate::Input>> {
        let dynamic_offset = (4 * self.op.get_attr_int("num_features")? + 6) as i32;
        let mut Inputs = vec![];
        for i in dynamic_offset..dynamic_offset + self.op.get_attr_int("num_features")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
    /// Returns the 'max_depth' Input of this 'BoostedTreesUpdateEnsemble' operation.
    pub fn max_depth(&self) -> crate::Result<crate::Input> {
        let dynamic_offset = (5 * self.op.get_attr_int("num_features")? + 7) as i32;
        Ok(crate::Input {
            operation: &self.op,
            index: dynamic_offset,
        })
    }
    /// Returns the 'learning_rate' Input of this 'BoostedTreesUpdateEnsemble' operation.
    pub fn learning_rate(&self) -> crate::Result<crate::Input> {
        let dynamic_offset = (5 * self.op.get_attr_int("num_features")? + 8) as i32;
        Ok(crate::Input {
            operation: &self.op,
            index: dynamic_offset,
        })
    }
}
impl From<BoostedTreesUpdateEnsembleInst> for crate::Operation {
    fn from(inst: BoostedTreesUpdateEnsembleInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `BoostedTreesUpdateEnsemble::new().build(tree_ensemble_handle, feature_ids, node_ids, gains, thresholds, left_node_contribs, right_node_contribs, max_depth, learning_rate, scope)`.
pub fn boosted_trees_update_ensemble<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
    O6: ::std::convert::Into<crate::Output>,
    O7: ::std::convert::Into<crate::Output>,
    O8: ::std::convert::Into<crate::Output>,
>(
    tree_ensemble_handle: O0,
    feature_ids: O1,
    node_ids: O2,
    gains: O3,
    thresholds: O4,
    left_node_contribs: O5,
    right_node_contribs: O6,
    max_depth: O7,
    learning_rate: O8,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    BoostedTreesUpdateEnsemble::new().build(
        tree_ensemble_handle,
        feature_ids,
        node_ids,
        gains,
        thresholds,
        left_node_contribs,
        right_node_contribs,
        max_depth,
        learning_rate,
        scope,
    )
}

/// Builder for the `BoostedTreesUpdateEnsembleV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct BoostedTreesUpdateEnsembleV2 {
    num_features: ::std::option::Option<i64>,
    logits_dimension: ::std::option::Option<i64>,
    num_groups: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'BoostedTreesUpdateEnsembleV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct BoostedTreesUpdateEnsembleV2Inst {
    /// An instance of a fully built BoostedTreesUpdateEnsembleV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl BoostedTreesUpdateEnsembleV2 {
    /// Creates a new `BoostedTreesUpdateEnsembleV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `num_features` attribute.
    pub fn num_features<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.num_features = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `logits_dimension` attribute.
    pub fn logits_dimension<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.logits_dimension = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `num_groups` attribute.
    pub fn num_groups<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.num_groups = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `BoostedTreesUpdateEnsembleV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
        O6: ::std::convert::Into<crate::Output>,
        O7: ::std::convert::Into<crate::Output>,
        O8: ::std::convert::Into<crate::Output>,
        O9: ::std::convert::Into<crate::Output>,
        O10: ::std::convert::Into<crate::Output>,
        O11: ::std::convert::Into<crate::Output>,
    >(
        &self,
        tree_ensemble_handle: O0,
        feature_ids: O1,
        dimension_ids: O2,
        node_ids: O3,
        gains: O4,
        thresholds: O5,
        left_node_contribs: O6,
        right_node_contribs: O7,
        split_types: O8,
        max_depth: O9,
        learning_rate: O10,
        pruning_mode: O11,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            tree_ensemble_handle.into(),
            feature_ids.into(),
            dimension_ids.into(),
            node_ids.into(),
            gains.into(),
            thresholds.into(),
            left_node_contribs.into(),
            right_node_contribs.into(),
            split_types.into(),
            max_depth.into(),
            learning_rate.into(),
            pruning_mode.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        tree_ensemble_handle: crate::Output,
        feature_ids: crate::Output,
        dimension_ids: crate::Output,
        node_ids: crate::Output,
        gains: crate::Output,
        thresholds: crate::Output,
        left_node_contribs: crate::Output,
        right_node_contribs: crate::Output,
        split_types: crate::Output,
        max_depth: crate::Output,
        learning_rate: crate::Output,
        pruning_mode: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("BoostedTreesUpdateEnsembleV2", |nd| {
            nd.add_input(tree_ensemble_handle);
            nd.add_input(feature_ids);
            nd.add_input(dimension_ids);
            nd.add_input(node_ids);
            nd.add_input(gains);
            nd.add_input(thresholds);
            nd.add_input(left_node_contribs);
            nd.add_input(right_node_contribs);
            nd.add_input(split_types);
            nd.add_input(max_depth);
            nd.add_input(learning_rate);
            nd.add_input(pruning_mode);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.num_features {
                nd.set_attr_int("num_features", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.logits_dimension {
                nd.set_attr_int("logits_dimension", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_groups {
                nd.set_attr_int("num_groups", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'BoostedTreesUpdateEnsembleV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        tree_ensemble_handle: crate::Output,
        feature_ids: Vec<crate::Output>,
        dimension_ids: Vec<crate::Output>,
        node_ids: Vec<crate::Output>,
        gains: Vec<crate::Output>,
        thresholds: Vec<crate::Output>,
        left_node_contribs: Vec<crate::Output>,
        right_node_contribs: Vec<crate::Output>,
        split_types: Vec<crate::Output>,
        max_depth: crate::Output,
        learning_rate: crate::Output,
        pruning_mode: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<BoostedTreesUpdateEnsembleV2Inst> {
        let op = scope.new_operation("BoostedTreesUpdateEnsembleV2", |builder| {
            builder.add_input(tree_ensemble_handle);
            builder.add_input_list(&feature_ids);
            builder.add_input_list(&dimension_ids);
            builder.add_input_list(&node_ids);
            builder.add_input_list(&gains);
            builder.add_input_list(&thresholds);
            builder.add_input_list(&left_node_contribs);
            builder.add_input_list(&right_node_contribs);
            builder.add_input_list(&split_types);
            builder.add_input(max_depth);
            builder.add_input(learning_rate);
            builder.add_input(pruning_mode);
            builder.set_attr_int("num_features", dimension_ids.clone().len() as i64)?;
            if let ::std::option::Option::Some(value) = &self.logits_dimension {
                builder.set_attr_int("logits_dimension", *value)?;
            }
            builder.set_attr_int("num_groups", feature_ids.clone().len() as i64)?;
            ::std::result::Result::Ok(())
        })?;
        Ok(BoostedTreesUpdateEnsembleV2Inst { op })
    }
}
impl BoostedTreesUpdateEnsembleV2Inst {
    /// Returns the 'tree_ensemble_handle' Input of this 'BoostedTreesUpdateEnsembleV2' operation.
    pub fn tree_ensemble_handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns a Vector of feature_ids for 'feature_ids' Input of this BoostedTreesUpdateEnsembleV2 operation.
    pub fn feature_ids(&self) -> crate::Result<Vec<crate::Input>> {
        let mut Inputs = vec![];
        for i in 1..self.op.get_attr_int("num_groups")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
    /// Returns a Vector of dimension_ids for 'dimension_ids' Input of this BoostedTreesUpdateEnsembleV2 operation.
    pub fn dimension_ids(&self) -> crate::Result<Vec<crate::Input>> {
        let dynamic_offset = (self.op.get_attr_int("num_groups")? + 2) as i32;
        let mut Inputs = vec![];
        for i in dynamic_offset..dynamic_offset + self.op.get_attr_int("num_features")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
    /// Returns a Vector of node_ids for 'node_ids' Input of this BoostedTreesUpdateEnsembleV2 operation.
    pub fn node_ids(&self) -> crate::Result<Vec<crate::Input>> {
        let dynamic_offset = (self.op.get_attr_int("num_features")?
            + self.op.get_attr_int("num_groups")?
            + 3) as i32;
        let mut Inputs = vec![];
        for i in dynamic_offset..dynamic_offset + self.op.get_attr_int("num_features")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
    /// Returns a Vector of gains for 'gains' Input of this BoostedTreesUpdateEnsembleV2 operation.
    pub fn gains(&self) -> crate::Result<Vec<crate::Input>> {
        let dynamic_offset = (2 * self.op.get_attr_int("num_features")?
            + self.op.get_attr_int("num_groups")?
            + 4) as i32;
        let mut Inputs = vec![];
        for i in dynamic_offset..dynamic_offset + self.op.get_attr_int("num_features")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
    /// Returns a Vector of thresholds for 'thresholds' Input of this BoostedTreesUpdateEnsembleV2 operation.
    pub fn thresholds(&self) -> crate::Result<Vec<crate::Input>> {
        let dynamic_offset = (3 * self.op.get_attr_int("num_features")?
            + self.op.get_attr_int("num_groups")?
            + 5) as i32;
        let mut Inputs = vec![];
        for i in dynamic_offset..dynamic_offset + self.op.get_attr_int("num_features")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
    /// Returns a Vector of left_node_contribs for 'left_node_contribs' Input of this BoostedTreesUpdateEnsembleV2 operation.
    pub fn left_node_contribs(&self) -> crate::Result<Vec<crate::Input>> {
        let dynamic_offset = (self.op.get_attr_int("num_groups")?
            + 4 * self.op.get_attr_int("num_features")?
            + 6) as i32;
        let mut Inputs = vec![];
        for i in dynamic_offset..dynamic_offset + self.op.get_attr_int("num_features")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
    /// Returns a Vector of right_node_contribs for 'right_node_contribs' Input of this BoostedTreesUpdateEnsembleV2 operation.
    pub fn right_node_contribs(&self) -> crate::Result<Vec<crate::Input>> {
        let dynamic_offset = (5 * self.op.get_attr_int("num_features")?
            + self.op.get_attr_int("num_groups")?
            + 7) as i32;
        let mut Inputs = vec![];
        for i in dynamic_offset..dynamic_offset + self.op.get_attr_int("num_features")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
    /// Returns a Vector of split_types for 'split_types' Input of this BoostedTreesUpdateEnsembleV2 operation.
    pub fn split_types(&self) -> crate::Result<Vec<crate::Input>> {
        let dynamic_offset = (self.op.get_attr_int("num_groups")?
            + 6 * self.op.get_attr_int("num_features")?
            + 8) as i32;
        let mut Inputs = vec![];
        for i in dynamic_offset..dynamic_offset + self.op.get_attr_int("num_features")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
    /// Returns the 'max_depth' Input of this 'BoostedTreesUpdateEnsembleV2' operation.
    pub fn max_depth(&self) -> crate::Result<crate::Input> {
        let dynamic_offset = (self.op.get_attr_int("num_groups")?
            + 7 * self.op.get_attr_int("num_features")?
            + 9) as i32;
        Ok(crate::Input {
            operation: &self.op,
            index: dynamic_offset,
        })
    }
    /// Returns the 'learning_rate' Input of this 'BoostedTreesUpdateEnsembleV2' operation.
    pub fn learning_rate(&self) -> crate::Result<crate::Input> {
        let dynamic_offset = (self.op.get_attr_int("num_groups")?
            + 7 * self.op.get_attr_int("num_features")?
            + 10) as i32;
        Ok(crate::Input {
            operation: &self.op,
            index: dynamic_offset,
        })
    }
    /// Returns the 'pruning_mode' Input of this 'BoostedTreesUpdateEnsembleV2' operation.
    pub fn pruning_mode(&self) -> crate::Result<crate::Input> {
        let dynamic_offset = (7 * self.op.get_attr_int("num_features")?
            + self.op.get_attr_int("num_groups")?
            + 11) as i32;
        Ok(crate::Input {
            operation: &self.op,
            index: dynamic_offset,
        })
    }
}
impl From<BoostedTreesUpdateEnsembleV2Inst> for crate::Operation {
    fn from(inst: BoostedTreesUpdateEnsembleV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `BoostedTreesUpdateEnsembleV2::new().build(tree_ensemble_handle, feature_ids, dimension_ids, node_ids, gains, thresholds, left_node_contribs, right_node_contribs, split_types, max_depth, learning_rate, pruning_mode, scope)`.
pub fn boosted_trees_update_ensemble_v2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
    O6: ::std::convert::Into<crate::Output>,
    O7: ::std::convert::Into<crate::Output>,
    O8: ::std::convert::Into<crate::Output>,
    O9: ::std::convert::Into<crate::Output>,
    O10: ::std::convert::Into<crate::Output>,
    O11: ::std::convert::Into<crate::Output>,
>(
    tree_ensemble_handle: O0,
    feature_ids: O1,
    dimension_ids: O2,
    node_ids: O3,
    gains: O4,
    thresholds: O5,
    left_node_contribs: O6,
    right_node_contribs: O7,
    split_types: O8,
    max_depth: O9,
    learning_rate: O10,
    pruning_mode: O11,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    BoostedTreesUpdateEnsembleV2::new().build(
        tree_ensemble_handle,
        feature_ids,
        dimension_ids,
        node_ids,
        gains,
        thresholds,
        left_node_contribs,
        right_node_contribs,
        split_types,
        max_depth,
        learning_rate,
        pruning_mode,
        scope,
    )
}

/// Builder for the `BroadcastArgs` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct BroadcastArgs {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'BroadcastArgs' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct BroadcastArgsInst {
    /// An instance of a fully built BroadcastArgs Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl BroadcastArgs {
    /// Creates a new `BroadcastArgs`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `BroadcastArgs` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        s0: O0,
        s1: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(s0.into(), s1.into(), scope)
    }
    fn build_impl(
        &self,
        s0: crate::Output,
        s1: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("BroadcastArgs", |nd| {
            nd.add_input(s0);
            nd.add_input(s1);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'BroadcastArgs' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        s0: crate::Output,
        s1: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<BroadcastArgsInst> {
        let op = scope.new_operation("BroadcastArgs", |builder| {
            builder.add_input(s0);
            builder.add_input(s1);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(BroadcastArgsInst { op })
    }
}
impl BroadcastArgsInst {
    /// Returns the 'r0' Output of this 'BroadcastArgs' operation.
    pub fn r0(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 's0' Input of this 'BroadcastArgs' operation.
    pub fn s0(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 's1' Input of this 'BroadcastArgs' operation.
    pub fn s1(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<BroadcastArgsInst> for crate::Operation {
    fn from(inst: BroadcastArgsInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `BroadcastArgs::new().build(s0, s1, scope)`.
pub fn broadcast_args<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    s0: O0,
    s1: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    BroadcastArgs::new().build(s0, s1, scope)
}

/// Builder for the `BroadcastGradientArgs` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct BroadcastGradientArgs {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'BroadcastGradientArgs' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct BroadcastGradientArgsInst {
    /// An instance of a fully built BroadcastGradientArgs Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl BroadcastGradientArgs {
    /// Creates a new `BroadcastGradientArgs`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `BroadcastGradientArgs` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        s0: O0,
        s1: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(s0.into(), s1.into(), scope)
    }
    fn build_impl(
        &self,
        s0: crate::Output,
        s1: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("BroadcastGradientArgs", |nd| {
            nd.add_input(s0);
            nd.add_input(s1);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'BroadcastGradientArgs' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        s0: crate::Output,
        s1: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<BroadcastGradientArgsInst> {
        let op = scope.new_operation("BroadcastGradientArgs", |builder| {
            builder.add_input(s0);
            builder.add_input(s1);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(BroadcastGradientArgsInst { op })
    }
}
impl BroadcastGradientArgsInst {
    /// Returns the 'r0' Output of this 'BroadcastGradientArgs' operation.
    pub fn r0(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'r1' Output of this 'BroadcastGradientArgs' operation.
    pub fn r1(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 's0' Input of this 'BroadcastGradientArgs' operation.
    pub fn s0(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 's1' Input of this 'BroadcastGradientArgs' operation.
    pub fn s1(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<BroadcastGradientArgsInst> for crate::Operation {
    fn from(inst: BroadcastGradientArgsInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `BroadcastGradientArgs::new().build(s0, s1, scope)`.
pub fn broadcast_gradient_args<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    s0: O0,
    s1: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    BroadcastGradientArgs::new().build(s0, s1, scope)
}

/// Builder for the `BroadcastTo` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct BroadcastTo {
    T: ::std::option::Option<crate::DataType>,
    Tidx: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'BroadcastTo' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct BroadcastToInst {
    /// An instance of a fully built BroadcastTo Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl BroadcastTo {
    /// Creates a new `BroadcastTo`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tidx` attribute.
    pub fn Tidx<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Tidx = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `BroadcastTo` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        shape: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), shape.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        shape: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("BroadcastTo", |nd| {
            nd.add_input(input);
            nd.add_input(shape);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tidx {
                nd.set_attr_type("Tidx", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'BroadcastTo' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        shape: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<BroadcastToInst> {
        let op = scope.new_operation("BroadcastTo", |builder| {
            builder.add_input(input);
            builder.add_input(shape);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tidx {
                builder.set_attr_type("Tidx", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(BroadcastToInst { op })
    }
}
impl BroadcastToInst {
    /// Returns the 'output' Output of this 'BroadcastTo' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'BroadcastTo' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'shape' Input of this 'BroadcastTo' operation.
    pub fn shape(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<BroadcastToInst> for crate::Operation {
    fn from(inst: BroadcastToInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `BroadcastTo::new().build(input, shape, scope)`.
pub fn broadcast_to<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    input: O0,
    shape: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    BroadcastTo::new().build(input, shape, scope)
}

/// Builder for the `Bucketize` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Bucketize {
    T: ::std::option::Option<crate::DataType>,
    boundaries: ::std::option::Option<::std::vec::Vec<f32>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Bucketize' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct BucketizeInst {
    /// An instance of a fully built Bucketize Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Bucketize {
    /// Creates a new `Bucketize`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `boundaries` attribute.
    pub fn boundaries<ArgType: ::std::convert::Into<::std::vec::Vec<f32>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.boundaries = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Bucketize` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Bucketize", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.boundaries {
                nd.set_attr_float_list("boundaries", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Bucketize' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<BucketizeInst> {
        let op = scope.new_operation("Bucketize", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.boundaries {
                builder.set_attr_float_list("boundaries", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(BucketizeInst { op })
    }
}
impl BucketizeInst {
    /// Returns the 'output' Output of this 'Bucketize' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'Bucketize' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<BucketizeInst> for crate::Operation {
    fn from(inst: BucketizeInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Bucketize::new().build(input, scope)`.
pub fn bucketize<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Bucketize::new().build(input, scope)
}

/// Builder for the `BytesProducedStatsDataset` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct BytesProducedStatsDataset {
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'BytesProducedStatsDataset' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct BytesProducedStatsDatasetInst {
    /// An instance of a fully built BytesProducedStatsDataset Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl BytesProducedStatsDataset {
    /// Creates a new `BytesProducedStatsDataset`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `BytesProducedStatsDataset` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input_dataset: O0,
        tag: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input_dataset.into(), tag.into(), scope)
    }
    fn build_impl(
        &self,
        input_dataset: crate::Output,
        tag: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("BytesProducedStatsDataset", |nd| {
            nd.add_input(input_dataset);
            nd.add_input(tag);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'BytesProducedStatsDataset' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_dataset: crate::Output,
        tag: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<BytesProducedStatsDatasetInst> {
        let op = scope.new_operation("BytesProducedStatsDataset", |builder| {
            builder.add_input(input_dataset);
            builder.add_input(tag);
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(BytesProducedStatsDatasetInst { op })
    }
}
impl BytesProducedStatsDatasetInst {
    /// Returns the 'handle' Output of this 'BytesProducedStatsDataset' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_dataset' Input of this 'BytesProducedStatsDataset' operation.
    pub fn input_dataset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'tag' Input of this 'BytesProducedStatsDataset' operation.
    pub fn tag(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<BytesProducedStatsDatasetInst> for crate::Operation {
    fn from(inst: BytesProducedStatsDatasetInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `BytesProducedStatsDataset::new().build(input_dataset, tag, scope)`.
pub fn bytes_produced_stats_dataset<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    input_dataset: O0,
    tag: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    BytesProducedStatsDataset::new().build(input_dataset, tag, scope)
}

/// Builder for the `CSRSparseMatrixComponents` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct CSRSparseMatrixComponents {
    type_: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'CSRSparseMatrixComponents' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct CSRSparseMatrixComponentsInst {
    /// An instance of a fully built CSRSparseMatrixComponents Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl CSRSparseMatrixComponents {
    /// Creates a new `CSRSparseMatrixComponents`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `type` attribute.
    pub fn type_<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.type_ = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `CSRSparseMatrixComponents` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        csr_sparse_matrix: O0,
        index: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(csr_sparse_matrix.into(), index.into(), scope)
    }
    fn build_impl(
        &self,
        csr_sparse_matrix: crate::Output,
        index: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("CSRSparseMatrixComponents", |nd| {
            nd.add_input(csr_sparse_matrix);
            nd.add_input(index);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.type_ {
                nd.set_attr_type("type", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'CSRSparseMatrixComponents' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        csr_sparse_matrix: crate::Output,
        index: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<CSRSparseMatrixComponentsInst> {
        let op = scope.new_operation("CSRSparseMatrixComponents", |builder| {
            builder.add_input(csr_sparse_matrix);
            builder.add_input(index);
            if let ::std::option::Option::Some(value) = &self.type_ {
                builder.set_attr_type("type", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(CSRSparseMatrixComponentsInst { op })
    }
}
impl CSRSparseMatrixComponentsInst {
    /// Returns the 'row_ptrs' Output of this 'CSRSparseMatrixComponents' operation.
    pub fn row_ptrs(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'col_inds' Output of this 'CSRSparseMatrixComponents' operation.
    pub fn col_inds(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'values' Output of this 'CSRSparseMatrixComponents' operation.
    pub fn values(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns the 'csr_sparse_matrix' Input of this 'CSRSparseMatrixComponents' operation.
    pub fn csr_sparse_matrix(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'index' Input of this 'CSRSparseMatrixComponents' operation.
    pub fn index(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<CSRSparseMatrixComponentsInst> for crate::Operation {
    fn from(inst: CSRSparseMatrixComponentsInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `CSRSparseMatrixComponents::new().build(csr_sparse_matrix, index, scope)`.
pub fn csrsparse_matrix_components<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    csr_sparse_matrix: O0,
    index: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    CSRSparseMatrixComponents::new().build(csr_sparse_matrix, index, scope)
}

/// Builder for the `CSRSparseMatrixToDense` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct CSRSparseMatrixToDense {
    type_: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'CSRSparseMatrixToDense' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct CSRSparseMatrixToDenseInst {
    /// An instance of a fully built CSRSparseMatrixToDense Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl CSRSparseMatrixToDense {
    /// Creates a new `CSRSparseMatrixToDense`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `type` attribute.
    pub fn type_<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.type_ = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `CSRSparseMatrixToDense` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        sparse_input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(sparse_input.into(), scope)
    }
    fn build_impl(
        &self,
        sparse_input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("CSRSparseMatrixToDense", |nd| {
            nd.add_input(sparse_input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.type_ {
                nd.set_attr_type("type", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'CSRSparseMatrixToDense' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        sparse_input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<CSRSparseMatrixToDenseInst> {
        let op = scope.new_operation("CSRSparseMatrixToDense", |builder| {
            builder.add_input(sparse_input);
            if let ::std::option::Option::Some(value) = &self.type_ {
                builder.set_attr_type("type", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(CSRSparseMatrixToDenseInst { op })
    }
}
impl CSRSparseMatrixToDenseInst {
    /// Returns the 'dense_output' Output of this 'CSRSparseMatrixToDense' operation.
    pub fn dense_output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'sparse_input' Input of this 'CSRSparseMatrixToDense' operation.
    pub fn sparse_input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<CSRSparseMatrixToDenseInst> for crate::Operation {
    fn from(inst: CSRSparseMatrixToDenseInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `CSRSparseMatrixToDense::new().build(sparse_input, scope)`.
pub fn csrsparse_matrix_to_dense<O0: ::std::convert::Into<crate::Output>>(
    sparse_input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    CSRSparseMatrixToDense::new().build(sparse_input, scope)
}

/// Builder for the `CSRSparseMatrixToSparseTensor` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct CSRSparseMatrixToSparseTensor {
    type_: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'CSRSparseMatrixToSparseTensor' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct CSRSparseMatrixToSparseTensorInst {
    /// An instance of a fully built CSRSparseMatrixToSparseTensor Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl CSRSparseMatrixToSparseTensor {
    /// Creates a new `CSRSparseMatrixToSparseTensor`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `type` attribute.
    pub fn type_<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.type_ = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `CSRSparseMatrixToSparseTensor` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        sparse_matrix: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(sparse_matrix.into(), scope)
    }
    fn build_impl(
        &self,
        sparse_matrix: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("CSRSparseMatrixToSparseTensor", |nd| {
            nd.add_input(sparse_matrix);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.type_ {
                nd.set_attr_type("type", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'CSRSparseMatrixToSparseTensor' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        sparse_matrix: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<CSRSparseMatrixToSparseTensorInst> {
        let op = scope.new_operation("CSRSparseMatrixToSparseTensor", |builder| {
            builder.add_input(sparse_matrix);
            if let ::std::option::Option::Some(value) = &self.type_ {
                builder.set_attr_type("type", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(CSRSparseMatrixToSparseTensorInst { op })
    }
}
impl CSRSparseMatrixToSparseTensorInst {
    /// Returns the 'indices' Output of this 'CSRSparseMatrixToSparseTensor' operation.
    pub fn indices(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'values' Output of this 'CSRSparseMatrixToSparseTensor' operation.
    pub fn values(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'dense_shape' Output of this 'CSRSparseMatrixToSparseTensor' operation.
    pub fn dense_shape(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns the 'sparse_matrix' Input of this 'CSRSparseMatrixToSparseTensor' operation.
    pub fn sparse_matrix(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<CSRSparseMatrixToSparseTensorInst> for crate::Operation {
    fn from(inst: CSRSparseMatrixToSparseTensorInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `CSRSparseMatrixToSparseTensor::new().build(sparse_matrix, scope)`.
pub fn csrsparse_matrix_to_sparse_tensor<O0: ::std::convert::Into<crate::Output>>(
    sparse_matrix: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    CSRSparseMatrixToSparseTensor::new().build(sparse_matrix, scope)
}

/// Builder for the `CSVDataset` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct CSVDataset {
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'CSVDataset' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct CSVDatasetInst {
    /// An instance of a fully built CSVDataset Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl CSVDataset {
    /// Creates a new `CSVDataset`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `CSVDataset` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
        O6: ::std::convert::Into<crate::Output>,
        O7: ::std::convert::Into<crate::Output>,
        O8: ::std::convert::Into<crate::Output>,
    >(
        &self,
        filenames: O0,
        compression_type: O1,
        buffer_size: O2,
        header: O3,
        field_delim: O4,
        use_quote_delim: O5,
        na_value: O6,
        select_cols: O7,
        record_defaults: O8,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            filenames.into(),
            compression_type.into(),
            buffer_size.into(),
            header.into(),
            field_delim.into(),
            use_quote_delim.into(),
            na_value.into(),
            select_cols.into(),
            record_defaults.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        filenames: crate::Output,
        compression_type: crate::Output,
        buffer_size: crate::Output,
        header: crate::Output,
        field_delim: crate::Output,
        use_quote_delim: crate::Output,
        na_value: crate::Output,
        select_cols: crate::Output,
        record_defaults: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("CSVDataset", |nd| {
            nd.add_input(filenames);
            nd.add_input(compression_type);
            nd.add_input(buffer_size);
            nd.add_input(header);
            nd.add_input(field_delim);
            nd.add_input(use_quote_delim);
            nd.add_input(na_value);
            nd.add_input(select_cols);
            nd.add_input(record_defaults);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'CSVDataset' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        filenames: crate::Output,
        compression_type: crate::Output,
        buffer_size: crate::Output,
        header: crate::Output,
        field_delim: crate::Output,
        use_quote_delim: crate::Output,
        na_value: crate::Output,
        select_cols: crate::Output,
        record_defaults: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<CSVDatasetInst> {
        let op = scope.new_operation("CSVDataset", |builder| {
            builder.add_input(filenames);
            builder.add_input(compression_type);
            builder.add_input(buffer_size);
            builder.add_input(header);
            builder.add_input(field_delim);
            builder.add_input(use_quote_delim);
            builder.add_input(na_value);
            builder.add_input(select_cols);
            builder.add_input(record_defaults);
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(CSVDatasetInst { op })
    }
}
impl CSVDatasetInst {
    /// Returns the 'handle' Output of this 'CSVDataset' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'filenames' Input of this 'CSVDataset' operation.
    pub fn filenames(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'compression_type' Input of this 'CSVDataset' operation.
    pub fn compression_type(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'buffer_size' Input of this 'CSVDataset' operation.
    pub fn buffer_size(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'header' Input of this 'CSVDataset' operation.
    pub fn header(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'field_delim' Input of this 'CSVDataset' operation.
    pub fn field_delim(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
    /// Returns the 'use_quote_delim' Input of this 'CSVDataset' operation.
    pub fn use_quote_delim(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 5,
        }
    }
    /// Returns the 'na_value' Input of this 'CSVDataset' operation.
    pub fn na_value(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 6,
        }
    }
    /// Returns the 'select_cols' Input of this 'CSVDataset' operation.
    pub fn select_cols(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 7,
        }
    }
    /// Returns the 'record_defaults' Input of this 'CSVDataset' operation.
    pub fn record_defaults(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 8,
        }
    }
}
impl From<CSVDatasetInst> for crate::Operation {
    fn from(inst: CSVDatasetInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `CSVDataset::new().build(filenames, compression_type, buffer_size, header, field_delim, use_quote_delim, na_value, select_cols, record_defaults, scope)`.
pub fn csvdataset<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
    O6: ::std::convert::Into<crate::Output>,
    O7: ::std::convert::Into<crate::Output>,
    O8: ::std::convert::Into<crate::Output>,
>(
    filenames: O0,
    compression_type: O1,
    buffer_size: O2,
    header: O3,
    field_delim: O4,
    use_quote_delim: O5,
    na_value: O6,
    select_cols: O7,
    record_defaults: O8,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    CSVDataset::new().build(
        filenames,
        compression_type,
        buffer_size,
        header,
        field_delim,
        use_quote_delim,
        na_value,
        select_cols,
        record_defaults,
        scope,
    )
}

/// Builder for the `CSVDatasetV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct CSVDatasetV2 {
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'CSVDatasetV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct CSVDatasetV2Inst {
    /// An instance of a fully built CSVDatasetV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl CSVDatasetV2 {
    /// Creates a new `CSVDatasetV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `CSVDatasetV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
        O6: ::std::convert::Into<crate::Output>,
        O7: ::std::convert::Into<crate::Output>,
        O8: ::std::convert::Into<crate::Output>,
        O9: ::std::convert::Into<crate::Output>,
    >(
        &self,
        filenames: O0,
        compression_type: O1,
        buffer_size: O2,
        header: O3,
        field_delim: O4,
        use_quote_delim: O5,
        na_value: O6,
        select_cols: O7,
        record_defaults: O8,
        exclude_cols: O9,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            filenames.into(),
            compression_type.into(),
            buffer_size.into(),
            header.into(),
            field_delim.into(),
            use_quote_delim.into(),
            na_value.into(),
            select_cols.into(),
            record_defaults.into(),
            exclude_cols.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        filenames: crate::Output,
        compression_type: crate::Output,
        buffer_size: crate::Output,
        header: crate::Output,
        field_delim: crate::Output,
        use_quote_delim: crate::Output,
        na_value: crate::Output,
        select_cols: crate::Output,
        record_defaults: crate::Output,
        exclude_cols: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("CSVDatasetV2", |nd| {
            nd.add_input(filenames);
            nd.add_input(compression_type);
            nd.add_input(buffer_size);
            nd.add_input(header);
            nd.add_input(field_delim);
            nd.add_input(use_quote_delim);
            nd.add_input(na_value);
            nd.add_input(select_cols);
            nd.add_input(record_defaults);
            nd.add_input(exclude_cols);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'CSVDatasetV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        filenames: crate::Output,
        compression_type: crate::Output,
        buffer_size: crate::Output,
        header: crate::Output,
        field_delim: crate::Output,
        use_quote_delim: crate::Output,
        na_value: crate::Output,
        select_cols: crate::Output,
        record_defaults: crate::Output,
        exclude_cols: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<CSVDatasetV2Inst> {
        let op = scope.new_operation("CSVDatasetV2", |builder| {
            builder.add_input(filenames);
            builder.add_input(compression_type);
            builder.add_input(buffer_size);
            builder.add_input(header);
            builder.add_input(field_delim);
            builder.add_input(use_quote_delim);
            builder.add_input(na_value);
            builder.add_input(select_cols);
            builder.add_input(record_defaults);
            builder.add_input(exclude_cols);
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(CSVDatasetV2Inst { op })
    }
}
impl CSVDatasetV2Inst {
    /// Returns the 'handle' Output of this 'CSVDatasetV2' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'filenames' Input of this 'CSVDatasetV2' operation.
    pub fn filenames(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'compression_type' Input of this 'CSVDatasetV2' operation.
    pub fn compression_type(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'buffer_size' Input of this 'CSVDatasetV2' operation.
    pub fn buffer_size(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'header' Input of this 'CSVDatasetV2' operation.
    pub fn header(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'field_delim' Input of this 'CSVDatasetV2' operation.
    pub fn field_delim(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
    /// Returns the 'use_quote_delim' Input of this 'CSVDatasetV2' operation.
    pub fn use_quote_delim(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 5,
        }
    }
    /// Returns the 'na_value' Input of this 'CSVDatasetV2' operation.
    pub fn na_value(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 6,
        }
    }
    /// Returns the 'select_cols' Input of this 'CSVDatasetV2' operation.
    pub fn select_cols(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 7,
        }
    }
    /// Returns the 'record_defaults' Input of this 'CSVDatasetV2' operation.
    pub fn record_defaults(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 8,
        }
    }
    /// Returns the 'exclude_cols' Input of this 'CSVDatasetV2' operation.
    pub fn exclude_cols(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 9,
        }
    }
}
impl From<CSVDatasetV2Inst> for crate::Operation {
    fn from(inst: CSVDatasetV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `CSVDatasetV2::new().build(filenames, compression_type, buffer_size, header, field_delim, use_quote_delim, na_value, select_cols, record_defaults, exclude_cols, scope)`.
pub fn csvdataset_v2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
    O6: ::std::convert::Into<crate::Output>,
    O7: ::std::convert::Into<crate::Output>,
    O8: ::std::convert::Into<crate::Output>,
    O9: ::std::convert::Into<crate::Output>,
>(
    filenames: O0,
    compression_type: O1,
    buffer_size: O2,
    header: O3,
    field_delim: O4,
    use_quote_delim: O5,
    na_value: O6,
    select_cols: O7,
    record_defaults: O8,
    exclude_cols: O9,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    CSVDatasetV2::new().build(
        filenames,
        compression_type,
        buffer_size,
        header,
        field_delim,
        use_quote_delim,
        na_value,
        select_cols,
        record_defaults,
        exclude_cols,
        scope,
    )
}

/// Builder for the `CTCBeamSearchDecoder` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct CTCBeamSearchDecoder {
    beam_width: ::std::option::Option<i64>,
    top_paths: ::std::option::Option<i64>,
    merge_repeated: ::std::option::Option<bool>,
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'CTCBeamSearchDecoder' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct CTCBeamSearchDecoderInst {
    /// An instance of a fully built CTCBeamSearchDecoder Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl CTCBeamSearchDecoder {
    /// Creates a new `CTCBeamSearchDecoder`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `beam_width` attribute.
    pub fn beam_width<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.beam_width = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `top_paths` attribute.
    pub fn top_paths<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.top_paths = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `merge_repeated` attribute.
    pub fn merge_repeated<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.merge_repeated = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `CTCBeamSearchDecoder` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        inputs: O0,
        sequence_length: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(inputs.into(), sequence_length.into(), scope)
    }
    fn build_impl(
        &self,
        inputs: crate::Output,
        sequence_length: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("CTCBeamSearchDecoder", |nd| {
            nd.add_input(inputs);
            nd.add_input(sequence_length);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.beam_width {
                nd.set_attr_int("beam_width", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.top_paths {
                nd.set_attr_int("top_paths", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.merge_repeated {
                nd.set_attr_bool("merge_repeated", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'CTCBeamSearchDecoder' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        inputs: crate::Output,
        sequence_length: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<CTCBeamSearchDecoderInst> {
        let op = scope.new_operation("CTCBeamSearchDecoder", |builder| {
            builder.add_input(inputs);
            builder.add_input(sequence_length);
            if let ::std::option::Option::Some(value) = &self.beam_width {
                builder.set_attr_int("beam_width", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.top_paths {
                builder.set_attr_int("top_paths", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.merge_repeated {
                builder.set_attr_bool("merge_repeated", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(CTCBeamSearchDecoderInst { op })
    }
}
impl CTCBeamSearchDecoderInst {
    /// Returns a Vector of decoded_indices for 'decoded_indices' Output of this CTCBeamSearchDecoder operation.
    pub fn decoded_indices(&self) -> crate::Result<Vec<crate::Output>> {
        let mut Outputs = vec![];
        for i in 0..self.op.get_attr_int("top_paths")? as i32 {
            Outputs.push(crate::Output {
                operation: self.op.clone(),
                index: i,
            });
        }
        Ok(Outputs)
    }
    /// Returns a Vector of decoded_values for 'decoded_values' Output of this CTCBeamSearchDecoder operation.
    pub fn decoded_values(&self) -> crate::Result<Vec<crate::Output>> {
        let dynamic_offset = (self.op.get_attr_int("top_paths")? + 1) as i32;
        let mut Outputs = vec![];
        for i in dynamic_offset..dynamic_offset + self.op.get_attr_int("top_paths")? as i32 {
            Outputs.push(crate::Output {
                operation: self.op.clone(),
                index: i,
            });
        }
        Ok(Outputs)
    }
    /// Returns a Vector of decoded_shape for 'decoded_shape' Output of this CTCBeamSearchDecoder operation.
    pub fn decoded_shape(&self) -> crate::Result<Vec<crate::Output>> {
        let dynamic_offset = (2 * self.op.get_attr_int("top_paths")? + 2) as i32;
        let mut Outputs = vec![];
        for i in dynamic_offset..dynamic_offset + self.op.get_attr_int("top_paths")? as i32 {
            Outputs.push(crate::Output {
                operation: self.op.clone(),
                index: i,
            });
        }
        Ok(Outputs)
    }
    /// Returns the 'log_probability' Output of this 'CTCBeamSearchDecoder' operation.
    pub fn log_probability(&self) -> crate::Result<crate::Output> {
        let dynamic_offset = (3 * self.op.get_attr_int("top_paths")? + 3) as i32;
        Ok(crate::Output {
            operation: self.op.clone(),
            index: dynamic_offset,
        })
    }
    /// Returns the 'inputs' Input of this 'CTCBeamSearchDecoder' operation.
    pub fn inputs(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'sequence_length' Input of this 'CTCBeamSearchDecoder' operation.
    pub fn sequence_length(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<CTCBeamSearchDecoderInst> for crate::Operation {
    fn from(inst: CTCBeamSearchDecoderInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `CTCBeamSearchDecoder::new().build(inputs, sequence_length, scope)`.
pub fn ctcbeam_search_decoder<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    inputs: O0,
    sequence_length: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    CTCBeamSearchDecoder::new().build(inputs, sequence_length, scope)
}

/// Builder for the `CTCGreedyDecoder` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct CTCGreedyDecoder {
    merge_repeated: ::std::option::Option<bool>,
    blank_index: ::std::option::Option<i64>,
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'CTCGreedyDecoder' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct CTCGreedyDecoderInst {
    /// An instance of a fully built CTCGreedyDecoder Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl CTCGreedyDecoder {
    /// Creates a new `CTCGreedyDecoder`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `merge_repeated` attribute.
    pub fn merge_repeated<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.merge_repeated = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `blank_index` attribute.
    pub fn blank_index<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.blank_index = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `CTCGreedyDecoder` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        inputs: O0,
        sequence_length: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(inputs.into(), sequence_length.into(), scope)
    }
    fn build_impl(
        &self,
        inputs: crate::Output,
        sequence_length: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("CTCGreedyDecoder", |nd| {
            nd.add_input(inputs);
            nd.add_input(sequence_length);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.merge_repeated {
                nd.set_attr_bool("merge_repeated", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.blank_index {
                nd.set_attr_int("blank_index", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'CTCGreedyDecoder' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        inputs: crate::Output,
        sequence_length: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<CTCGreedyDecoderInst> {
        let op = scope.new_operation("CTCGreedyDecoder", |builder| {
            builder.add_input(inputs);
            builder.add_input(sequence_length);
            if let ::std::option::Option::Some(value) = &self.merge_repeated {
                builder.set_attr_bool("merge_repeated", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.blank_index {
                builder.set_attr_int("blank_index", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(CTCGreedyDecoderInst { op })
    }
}
impl CTCGreedyDecoderInst {
    /// Returns the 'decoded_indices' Output of this 'CTCGreedyDecoder' operation.
    pub fn decoded_indices(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'decoded_values' Output of this 'CTCGreedyDecoder' operation.
    pub fn decoded_values(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'decoded_shape' Output of this 'CTCGreedyDecoder' operation.
    pub fn decoded_shape(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns the 'log_probability' Output of this 'CTCGreedyDecoder' operation.
    pub fn log_probability(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 3,
        }
    }
    /// Returns the 'inputs' Input of this 'CTCGreedyDecoder' operation.
    pub fn inputs(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'sequence_length' Input of this 'CTCGreedyDecoder' operation.
    pub fn sequence_length(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<CTCGreedyDecoderInst> for crate::Operation {
    fn from(inst: CTCGreedyDecoderInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `CTCGreedyDecoder::new().build(inputs, sequence_length, scope)`.
pub fn ctcgreedy_decoder<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    inputs: O0,
    sequence_length: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    CTCGreedyDecoder::new().build(inputs, sequence_length, scope)
}

/// Builder for the `CTCLoss` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct CTCLoss {
    preprocess_collapse_repeated: ::std::option::Option<bool>,
    ctc_merge_repeated: ::std::option::Option<bool>,
    ignore_longer_outputs_than_inputs: ::std::option::Option<bool>,
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'CTCLoss' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct CTCLossInst {
    /// An instance of a fully built CTCLoss Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl CTCLoss {
    /// Creates a new `CTCLoss`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `preprocess_collapse_repeated` attribute.
    pub fn preprocess_collapse_repeated<ArgType: ::std::convert::Into<bool>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.preprocess_collapse_repeated = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `ctc_merge_repeated` attribute.
    pub fn ctc_merge_repeated<ArgType: ::std::convert::Into<bool>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.ctc_merge_repeated = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `ignore_longer_outputs_than_inputs` attribute.
    pub fn ignore_longer_outputs_than_inputs<ArgType: ::std::convert::Into<bool>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.ignore_longer_outputs_than_inputs = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `CTCLoss` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
    >(
        &self,
        inputs: O0,
        labels_indices: O1,
        labels_values: O2,
        sequence_length: O3,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            inputs.into(),
            labels_indices.into(),
            labels_values.into(),
            sequence_length.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        inputs: crate::Output,
        labels_indices: crate::Output,
        labels_values: crate::Output,
        sequence_length: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("CTCLoss", |nd| {
            nd.add_input(inputs);
            nd.add_input(labels_indices);
            nd.add_input(labels_values);
            nd.add_input(sequence_length);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.preprocess_collapse_repeated {
                nd.set_attr_bool("preprocess_collapse_repeated", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.ctc_merge_repeated {
                nd.set_attr_bool("ctc_merge_repeated", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.ignore_longer_outputs_than_inputs {
                nd.set_attr_bool("ignore_longer_outputs_than_inputs", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'CTCLoss' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        inputs: crate::Output,
        labels_indices: crate::Output,
        labels_values: crate::Output,
        sequence_length: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<CTCLossInst> {
        let op = scope.new_operation("CTCLoss", |builder| {
            builder.add_input(inputs);
            builder.add_input(labels_indices);
            builder.add_input(labels_values);
            builder.add_input(sequence_length);
            if let ::std::option::Option::Some(value) = &self.preprocess_collapse_repeated {
                builder.set_attr_bool("preprocess_collapse_repeated", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.ctc_merge_repeated {
                builder.set_attr_bool("ctc_merge_repeated", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.ignore_longer_outputs_than_inputs {
                builder.set_attr_bool("ignore_longer_outputs_than_inputs", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(CTCLossInst { op })
    }
}
impl CTCLossInst {
    /// Returns the 'loss' Output of this 'CTCLoss' operation.
    pub fn loss(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'gradient' Output of this 'CTCLoss' operation.
    pub fn gradient(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'inputs' Input of this 'CTCLoss' operation.
    pub fn inputs(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'labels_indices' Input of this 'CTCLoss' operation.
    pub fn labels_indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'labels_values' Input of this 'CTCLoss' operation.
    pub fn labels_values(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'sequence_length' Input of this 'CTCLoss' operation.
    pub fn sequence_length(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
}
impl From<CTCLossInst> for crate::Operation {
    fn from(inst: CTCLossInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `CTCLoss::new().build(inputs, labels_indices, labels_values, sequence_length, scope)`.
pub fn ctcloss<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
>(
    inputs: O0,
    labels_indices: O1,
    labels_values: O2,
    sequence_length: O3,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    CTCLoss::new().build(
        inputs,
        labels_indices,
        labels_values,
        sequence_length,
        scope,
    )
}

/// Builder for the `CTCLossV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct CTCLossV2 {
    preprocess_collapse_repeated: ::std::option::Option<bool>,
    ctc_merge_repeated: ::std::option::Option<bool>,
    ignore_longer_outputs_than_inputs: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'CTCLossV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct CTCLossV2Inst {
    /// An instance of a fully built CTCLossV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl CTCLossV2 {
    /// Creates a new `CTCLossV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `preprocess_collapse_repeated` attribute.
    pub fn preprocess_collapse_repeated<ArgType: ::std::convert::Into<bool>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.preprocess_collapse_repeated = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `ctc_merge_repeated` attribute.
    pub fn ctc_merge_repeated<ArgType: ::std::convert::Into<bool>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.ctc_merge_repeated = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `ignore_longer_outputs_than_inputs` attribute.
    pub fn ignore_longer_outputs_than_inputs<ArgType: ::std::convert::Into<bool>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.ignore_longer_outputs_than_inputs = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `CTCLossV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
    >(
        &self,
        inputs: O0,
        labels_indices: O1,
        labels_values: O2,
        sequence_length: O3,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            inputs.into(),
            labels_indices.into(),
            labels_values.into(),
            sequence_length.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        inputs: crate::Output,
        labels_indices: crate::Output,
        labels_values: crate::Output,
        sequence_length: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("CTCLossV2", |nd| {
            nd.add_input(inputs);
            nd.add_input(labels_indices);
            nd.add_input(labels_values);
            nd.add_input(sequence_length);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.preprocess_collapse_repeated {
                nd.set_attr_bool("preprocess_collapse_repeated", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.ctc_merge_repeated {
                nd.set_attr_bool("ctc_merge_repeated", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.ignore_longer_outputs_than_inputs {
                nd.set_attr_bool("ignore_longer_outputs_than_inputs", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'CTCLossV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        inputs: crate::Output,
        labels_indices: crate::Output,
        labels_values: crate::Output,
        sequence_length: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<CTCLossV2Inst> {
        let op = scope.new_operation("CTCLossV2", |builder| {
            builder.add_input(inputs);
            builder.add_input(labels_indices);
            builder.add_input(labels_values);
            builder.add_input(sequence_length);
            if let ::std::option::Option::Some(value) = &self.preprocess_collapse_repeated {
                builder.set_attr_bool("preprocess_collapse_repeated", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.ctc_merge_repeated {
                builder.set_attr_bool("ctc_merge_repeated", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.ignore_longer_outputs_than_inputs {
                builder.set_attr_bool("ignore_longer_outputs_than_inputs", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(CTCLossV2Inst { op })
    }
}
impl CTCLossV2Inst {
    /// Returns the 'loss' Output of this 'CTCLossV2' operation.
    pub fn loss(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'gradient' Output of this 'CTCLossV2' operation.
    pub fn gradient(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'inputs' Input of this 'CTCLossV2' operation.
    pub fn inputs(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'labels_indices' Input of this 'CTCLossV2' operation.
    pub fn labels_indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'labels_values' Input of this 'CTCLossV2' operation.
    pub fn labels_values(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'sequence_length' Input of this 'CTCLossV2' operation.
    pub fn sequence_length(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
}
impl From<CTCLossV2Inst> for crate::Operation {
    fn from(inst: CTCLossV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `CTCLossV2::new().build(inputs, labels_indices, labels_values, sequence_length, scope)`.
pub fn ctcloss_v2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
>(
    inputs: O0,
    labels_indices: O1,
    labels_values: O2,
    sequence_length: O3,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    CTCLossV2::new().build(
        inputs,
        labels_indices,
        labels_values,
        sequence_length,
        scope,
    )
}

/// Builder for the `CacheDataset` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct CacheDataset {
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    metadata: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'CacheDataset' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct CacheDatasetInst {
    /// An instance of a fully built CacheDataset Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl CacheDataset {
    /// Creates a new `CacheDataset`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `metadata` attribute.
    pub fn metadata<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.metadata = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `CacheDataset` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input_dataset: O0,
        filename: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input_dataset.into(), filename.into(), scope)
    }
    fn build_impl(
        &self,
        input_dataset: crate::Output,
        filename: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("CacheDataset", |nd| {
            nd.add_input(input_dataset);
            nd.add_input(filename);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.metadata {
                nd.set_attr_string("metadata", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'CacheDataset' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_dataset: crate::Output,
        filename: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<CacheDatasetInst> {
        let op = scope.new_operation("CacheDataset", |builder| {
            builder.add_input(input_dataset);
            builder.add_input(filename);
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.metadata {
                builder.set_attr_string("metadata", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(CacheDatasetInst { op })
    }
}
impl CacheDatasetInst {
    /// Returns the 'handle' Output of this 'CacheDataset' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_dataset' Input of this 'CacheDataset' operation.
    pub fn input_dataset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'filename' Input of this 'CacheDataset' operation.
    pub fn filename(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<CacheDatasetInst> for crate::Operation {
    fn from(inst: CacheDatasetInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `CacheDataset::new().build(input_dataset, filename, scope)`.
pub fn cache_dataset<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    input_dataset: O0,
    filename: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    CacheDataset::new().build(input_dataset, filename, scope)
}

/// Builder for the `CacheDatasetV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct CacheDatasetV2 {
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    metadata: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'CacheDatasetV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct CacheDatasetV2Inst {
    /// An instance of a fully built CacheDatasetV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl CacheDatasetV2 {
    /// Creates a new `CacheDatasetV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `metadata` attribute.
    pub fn metadata<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.metadata = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `CacheDatasetV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input_dataset: O0,
        filename: O1,
        cache: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input_dataset.into(), filename.into(), cache.into(), scope)
    }
    fn build_impl(
        &self,
        input_dataset: crate::Output,
        filename: crate::Output,
        cache: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("CacheDatasetV2", |nd| {
            nd.add_input(input_dataset);
            nd.add_input(filename);
            nd.add_input(cache);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.metadata {
                nd.set_attr_string("metadata", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'CacheDatasetV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_dataset: crate::Output,
        filename: crate::Output,
        cache: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<CacheDatasetV2Inst> {
        let op = scope.new_operation("CacheDatasetV2", |builder| {
            builder.add_input(input_dataset);
            builder.add_input(filename);
            builder.add_input(cache);
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.metadata {
                builder.set_attr_string("metadata", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(CacheDatasetV2Inst { op })
    }
}
impl CacheDatasetV2Inst {
    /// Returns the 'handle' Output of this 'CacheDatasetV2' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_dataset' Input of this 'CacheDatasetV2' operation.
    pub fn input_dataset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'filename' Input of this 'CacheDatasetV2' operation.
    pub fn filename(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'cache' Input of this 'CacheDatasetV2' operation.
    pub fn cache(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<CacheDatasetV2Inst> for crate::Operation {
    fn from(inst: CacheDatasetV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `CacheDatasetV2::new().build(input_dataset, filename, cache, scope)`.
pub fn cache_dataset_v2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    input_dataset: O0,
    filename: O1,
    cache: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    CacheDatasetV2::new().build(input_dataset, filename, cache, scope)
}

/// Builder for the `Case` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Case {
    Tin: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    Tout: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    branches: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Case' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct CaseInst {
    /// An instance of a fully built Case Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Case {
    /// Creates a new `Case`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `Tin` attribute.
    pub fn Tin<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tin = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tout` attribute.
    pub fn Tout<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tout = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `branches` attribute.
    pub fn branches<ArgType: ::std::convert::Into<::std::vec::Vec<::std::string::String>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.branches = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Case` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        branch_index: O0,
        input: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(branch_index.into(), input.into(), scope)
    }
    fn build_impl(
        &self,
        branch_index: crate::Output,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Case", |nd| {
            nd.add_input(branch_index);
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.Tin {
                nd.set_attr_type_list("Tin", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tout {
                nd.set_attr_type_list("Tout", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.branches {
                nd.set_attr_string_list("branches", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Case' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        branch_index: crate::Output,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<CaseInst> {
        let op = scope.new_operation("Case", |builder| {
            builder.add_input(branch_index);
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.Tin {
                builder.set_attr_type_list("Tin", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tout {
                builder.set_attr_type_list("Tout", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.branches {
                builder.set_attr_string_list("branches", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(CaseInst { op })
    }
}
impl CaseInst {
    /// Returns the 'output' Output of this 'Case' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'branch_index' Input of this 'Case' operation.
    pub fn branch_index(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'Case' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<CaseInst> for crate::Operation {
    fn from(inst: CaseInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Case::new().build(branch_index, input, scope)`.
pub fn case<O0: ::std::convert::Into<crate::Output>, O1: ::std::convert::Into<crate::Output>>(
    branch_index: O0,
    input: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Case::new().build(branch_index, input, scope)
}

/// Builder for the `Cast` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Cast {
    SrcT: ::std::option::Option<crate::DataType>,
    DstT: ::std::option::Option<crate::DataType>,
    Truncate: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Cast' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct CastInst {
    /// An instance of a fully built Cast Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Cast {
    /// Creates a new `Cast`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `SrcT` attribute.
    pub fn SrcT<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.SrcT = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `DstT` attribute.
    pub fn DstT<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.DstT = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Truncate` attribute.
    pub fn Truncate<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.Truncate = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Cast` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        x: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Cast", |nd| {
            nd.add_input(x);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.SrcT {
                nd.set_attr_type("SrcT", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.DstT {
                nd.set_attr_type("DstT", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Truncate {
                nd.set_attr_bool("Truncate", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Cast' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<CastInst> {
        let op = scope.new_operation("Cast", |builder| {
            builder.add_input(x);
            if let ::std::option::Option::Some(value) = &self.SrcT {
                builder.set_attr_type("SrcT", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.DstT {
                builder.set_attr_type("DstT", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Truncate {
                builder.set_attr_bool("Truncate", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(CastInst { op })
    }
}
impl CastInst {
    /// Returns the 'y' Output of this 'Cast' operation.
    pub fn y(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'Cast' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<CastInst> for crate::Operation {
    fn from(inst: CastInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Cast::new().build(x, scope)`.
pub fn cast<O0: ::std::convert::Into<crate::Output>>(
    x: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Cast::new().build(x, scope)
}

/// Builder for the `Ceil` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Ceil {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Ceil' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct CeilInst {
    /// An instance of a fully built Ceil Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Ceil {
    /// Creates a new `Ceil`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Ceil` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        x: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Ceil", |nd| {
            nd.add_input(x);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Ceil' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<CeilInst> {
        let op = scope.new_operation("Ceil", |builder| {
            builder.add_input(x);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(CeilInst { op })
    }
}
impl CeilInst {
    /// Returns the 'y' Output of this 'Ceil' operation.
    pub fn y(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'Ceil' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<CeilInst> for crate::Operation {
    fn from(inst: CeilInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Ceil::new().build(x, scope)`.
pub fn ceil<O0: ::std::convert::Into<crate::Output>>(
    x: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Ceil::new().build(x, scope)
}

/// Builder for the `CheckNumerics` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct CheckNumerics {
    T: ::std::option::Option<crate::DataType>,
    message: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'CheckNumerics' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct CheckNumericsInst {
    /// An instance of a fully built CheckNumerics Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl CheckNumerics {
    /// Creates a new `CheckNumerics`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `message` attribute.
    pub fn message<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.message = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `CheckNumerics` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        tensor: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(tensor.into(), scope)
    }
    fn build_impl(
        &self,
        tensor: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("CheckNumerics", |nd| {
            nd.add_input(tensor);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.message {
                nd.set_attr_string("message", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'CheckNumerics' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        tensor: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<CheckNumericsInst> {
        let op = scope.new_operation("CheckNumerics", |builder| {
            builder.add_input(tensor);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.message {
                builder.set_attr_string("message", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(CheckNumericsInst { op })
    }
}
impl CheckNumericsInst {
    /// Returns the 'output' Output of this 'CheckNumerics' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'tensor' Input of this 'CheckNumerics' operation.
    pub fn tensor(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<CheckNumericsInst> for crate::Operation {
    fn from(inst: CheckNumericsInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `CheckNumerics::new().build(tensor, scope)`.
pub fn check_numerics<O0: ::std::convert::Into<crate::Output>>(
    tensor: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    CheckNumerics::new().build(tensor, scope)
}

/// Builder for the `CheckNumericsV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct CheckNumericsV2 {
    T: ::std::option::Option<crate::DataType>,
    message: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'CheckNumericsV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct CheckNumericsV2Inst {
    /// An instance of a fully built CheckNumericsV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl CheckNumericsV2 {
    /// Creates a new `CheckNumericsV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `message` attribute.
    pub fn message<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.message = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `CheckNumericsV2` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        tensor: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(tensor.into(), scope)
    }
    fn build_impl(
        &self,
        tensor: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("CheckNumericsV2", |nd| {
            nd.add_input(tensor);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.message {
                nd.set_attr_string("message", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'CheckNumericsV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        tensor: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<CheckNumericsV2Inst> {
        let op = scope.new_operation("CheckNumericsV2", |builder| {
            builder.add_input(tensor);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.message {
                builder.set_attr_string("message", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(CheckNumericsV2Inst { op })
    }
}
impl CheckNumericsV2Inst {
    /// Returns the 'output' Output of this 'CheckNumericsV2' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'tensor' Input of this 'CheckNumericsV2' operation.
    pub fn tensor(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<CheckNumericsV2Inst> for crate::Operation {
    fn from(inst: CheckNumericsV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `CheckNumericsV2::new().build(tensor, scope)`.
pub fn check_numerics_v2<O0: ::std::convert::Into<crate::Output>>(
    tensor: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    CheckNumericsV2::new().build(tensor, scope)
}

/// Builder for the `Cholesky` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Cholesky {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Cholesky' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct CholeskyInst {
    /// An instance of a fully built Cholesky Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Cholesky {
    /// Creates a new `Cholesky`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Cholesky` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Cholesky", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Cholesky' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<CholeskyInst> {
        let op = scope.new_operation("Cholesky", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(CholeskyInst { op })
    }
}
impl CholeskyInst {
    /// Returns the 'output' Output of this 'Cholesky' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'Cholesky' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<CholeskyInst> for crate::Operation {
    fn from(inst: CholeskyInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Cholesky::new().build(input, scope)`.
pub fn cholesky<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Cholesky::new().build(input, scope)
}

/// Builder for the `CholeskyGrad` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct CholeskyGrad {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'CholeskyGrad' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct CholeskyGradInst {
    /// An instance of a fully built CholeskyGrad Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl CholeskyGrad {
    /// Creates a new `CholeskyGrad`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `CholeskyGrad` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        l: O0,
        grad: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(l.into(), grad.into(), scope)
    }
    fn build_impl(
        &self,
        l: crate::Output,
        grad: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("CholeskyGrad", |nd| {
            nd.add_input(l);
            nd.add_input(grad);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'CholeskyGrad' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        l: crate::Output,
        grad: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<CholeskyGradInst> {
        let op = scope.new_operation("CholeskyGrad", |builder| {
            builder.add_input(l);
            builder.add_input(grad);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(CholeskyGradInst { op })
    }
}
impl CholeskyGradInst {
    /// Returns the 'output' Output of this 'CholeskyGrad' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'l' Input of this 'CholeskyGrad' operation.
    pub fn l(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'grad' Input of this 'CholeskyGrad' operation.
    pub fn grad(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<CholeskyGradInst> for crate::Operation {
    fn from(inst: CholeskyGradInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `CholeskyGrad::new().build(l, grad, scope)`.
pub fn cholesky_grad<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    l: O0,
    grad: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    CholeskyGrad::new().build(l, grad, scope)
}

/// Builder for the `ChooseFastestBranchDataset` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ChooseFastestBranchDataset {
    Targuments: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    num_elements_per_branch: ::std::option::Option<i64>,
    branches: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
    other_arguments_lengths: ::std::option::Option<::std::vec::Vec<i64>>,
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ChooseFastestBranchDataset' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ChooseFastestBranchDatasetInst {
    /// An instance of a fully built ChooseFastestBranchDataset Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ChooseFastestBranchDataset {
    /// Creates a new `ChooseFastestBranchDataset`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `Targuments` attribute.
    pub fn Targuments<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Targuments = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `num_elements_per_branch` attribute.
    pub fn num_elements_per_branch<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.num_elements_per_branch = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `branches` attribute.
    pub fn branches<ArgType: ::std::convert::Into<::std::vec::Vec<::std::string::String>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.branches = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `other_arguments_lengths` attribute.
    pub fn other_arguments_lengths<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.other_arguments_lengths = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ChooseFastestBranchDataset` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input_dataset: O0,
        ratio_numerator: O1,
        ratio_denominator: O2,
        other_arguments: O3,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            input_dataset.into(),
            ratio_numerator.into(),
            ratio_denominator.into(),
            other_arguments.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        input_dataset: crate::Output,
        ratio_numerator: crate::Output,
        ratio_denominator: crate::Output,
        other_arguments: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ChooseFastestBranchDataset", |nd| {
            nd.add_input(input_dataset);
            nd.add_input(ratio_numerator);
            nd.add_input(ratio_denominator);
            nd.add_input(other_arguments);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.Targuments {
                nd.set_attr_type_list("Targuments", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_elements_per_branch {
                nd.set_attr_int("num_elements_per_branch", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.branches {
                nd.set_attr_string_list("branches", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.other_arguments_lengths {
                nd.set_attr_int_list("other_arguments_lengths", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ChooseFastestBranchDataset' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_dataset: crate::Output,
        ratio_numerator: crate::Output,
        ratio_denominator: crate::Output,
        other_arguments: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ChooseFastestBranchDatasetInst> {
        let op = scope.new_operation("ChooseFastestBranchDataset", |builder| {
            builder.add_input(input_dataset);
            builder.add_input(ratio_numerator);
            builder.add_input(ratio_denominator);
            builder.add_input(other_arguments);
            if let ::std::option::Option::Some(value) = &self.Targuments {
                builder.set_attr_type_list("Targuments", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_elements_per_branch {
                builder.set_attr_int("num_elements_per_branch", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.branches {
                builder.set_attr_string_list("branches", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.other_arguments_lengths {
                builder.set_attr_int_list("other_arguments_lengths", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ChooseFastestBranchDatasetInst { op })
    }
}
impl ChooseFastestBranchDatasetInst {
    /// Returns the 'handle' Output of this 'ChooseFastestBranchDataset' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_dataset' Input of this 'ChooseFastestBranchDataset' operation.
    pub fn input_dataset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'ratio_numerator' Input of this 'ChooseFastestBranchDataset' operation.
    pub fn ratio_numerator(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'ratio_denominator' Input of this 'ChooseFastestBranchDataset' operation.
    pub fn ratio_denominator(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'other_arguments' Input of this 'ChooseFastestBranchDataset' operation.
    pub fn other_arguments(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
}
impl From<ChooseFastestBranchDatasetInst> for crate::Operation {
    fn from(inst: ChooseFastestBranchDatasetInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ChooseFastestBranchDataset::new().build(input_dataset, ratio_numerator, ratio_denominator, other_arguments, scope)`.
pub fn choose_fastest_branch_dataset<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
>(
    input_dataset: O0,
    ratio_numerator: O1,
    ratio_denominator: O2,
    other_arguments: O3,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ChooseFastestBranchDataset::new().build(
        input_dataset,
        ratio_numerator,
        ratio_denominator,
        other_arguments,
        scope,
    )
}

/// Builder for the `ChooseFastestDataset` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ChooseFastestDataset {
    N: ::std::option::Option<i64>,
    num_experiments: ::std::option::Option<i64>,
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ChooseFastestDataset' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ChooseFastestDatasetInst {
    /// An instance of a fully built ChooseFastestDataset Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ChooseFastestDataset {
    /// Creates a new `ChooseFastestDataset`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `N` attribute.
    pub fn N<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.N = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `num_experiments` attribute.
    pub fn num_experiments<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.num_experiments = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ChooseFastestDataset` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input_datasets: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input_datasets.into(), scope)
    }
    fn build_impl(
        &self,
        input_datasets: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ChooseFastestDataset", |nd| {
            nd.add_input(input_datasets);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.N {
                nd.set_attr_int("N", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_experiments {
                nd.set_attr_int("num_experiments", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ChooseFastestDataset' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_datasets: Vec<crate::Output>,
        scope: &mut crate::Scope,
    ) -> crate::Result<ChooseFastestDatasetInst> {
        let op = scope.new_operation("ChooseFastestDataset", |builder| {
            builder.add_input_list(&input_datasets);
            builder.set_attr_int("N", input_datasets.clone().len() as i64)?;
            if let ::std::option::Option::Some(value) = &self.num_experiments {
                builder.set_attr_int("num_experiments", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ChooseFastestDatasetInst { op })
    }
}
impl ChooseFastestDatasetInst {
    /// Returns the 'handle' Output of this 'ChooseFastestDataset' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns a Vector of input_datasets for 'input_datasets' Input of this ChooseFastestDataset operation.
    pub fn input_datasets(&self) -> crate::Result<Vec<crate::Input>> {
        let mut Inputs = vec![];
        for i in 0..self.op.get_attr_int("N")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
}
impl From<ChooseFastestDatasetInst> for crate::Operation {
    fn from(inst: ChooseFastestDatasetInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ChooseFastestDataset::new().build(input_datasets, scope)`.
pub fn choose_fastest_dataset<O0: ::std::convert::Into<crate::Output>>(
    input_datasets: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ChooseFastestDataset::new().build(input_datasets, scope)
}

/// Builder for the `ClipByValue` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ClipByValue {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ClipByValue' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ClipByValueInst {
    /// An instance of a fully built ClipByValue Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ClipByValue {
    /// Creates a new `ClipByValue`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ClipByValue` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        t: O0,
        clip_value_min: O1,
        clip_value_max: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            t.into(),
            clip_value_min.into(),
            clip_value_max.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        t: crate::Output,
        clip_value_min: crate::Output,
        clip_value_max: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ClipByValue", |nd| {
            nd.add_input(t);
            nd.add_input(clip_value_min);
            nd.add_input(clip_value_max);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ClipByValue' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        t: crate::Output,
        clip_value_min: crate::Output,
        clip_value_max: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ClipByValueInst> {
        let op = scope.new_operation("ClipByValue", |builder| {
            builder.add_input(t);
            builder.add_input(clip_value_min);
            builder.add_input(clip_value_max);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ClipByValueInst { op })
    }
}
impl ClipByValueInst {
    /// Returns the 'output' Output of this 'ClipByValue' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 't' Input of this 'ClipByValue' operation.
    pub fn t(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'clip_value_min' Input of this 'ClipByValue' operation.
    pub fn clip_value_min(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'clip_value_max' Input of this 'ClipByValue' operation.
    pub fn clip_value_max(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<ClipByValueInst> for crate::Operation {
    fn from(inst: ClipByValueInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ClipByValue::new().build(t, clip_value_min, clip_value_max, scope)`.
pub fn clip_by_value<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    t: O0,
    clip_value_min: O1,
    clip_value_max: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ClipByValue::new().build(t, clip_value_min, clip_value_max, scope)
}

/// Builder for the `CloseSummaryWriter` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct CloseSummaryWriter {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'CloseSummaryWriter' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct CloseSummaryWriterInst {
    /// An instance of a fully built CloseSummaryWriter Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl CloseSummaryWriter {
    /// Creates a new `CloseSummaryWriter`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `CloseSummaryWriter` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        writer: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(writer.into(), scope)
    }
    fn build_impl(
        &self,
        writer: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("CloseSummaryWriter", |nd| {
            nd.add_input(writer);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'CloseSummaryWriter' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        writer: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<CloseSummaryWriterInst> {
        let op = scope.new_operation("CloseSummaryWriter", |builder| {
            builder.add_input(writer);
            ::std::result::Result::Ok(())
        })?;
        Ok(CloseSummaryWriterInst { op })
    }
}
impl CloseSummaryWriterInst {
    /// Returns the 'writer' Input of this 'CloseSummaryWriter' operation.
    pub fn writer(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<CloseSummaryWriterInst> for crate::Operation {
    fn from(inst: CloseSummaryWriterInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `CloseSummaryWriter::new().build(writer, scope)`.
pub fn close_summary_writer<O0: ::std::convert::Into<crate::Output>>(
    writer: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    CloseSummaryWriter::new().build(writer, scope)
}

/// Builder for the `CollateTPUEmbeddingMemory` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct CollateTPUEmbeddingMemory {
    N: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'CollateTPUEmbeddingMemory' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct CollateTPUEmbeddingMemoryInst {
    /// An instance of a fully built CollateTPUEmbeddingMemory Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl CollateTPUEmbeddingMemory {
    /// Creates a new `CollateTPUEmbeddingMemory`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `N` attribute.
    pub fn N<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.N = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `CollateTPUEmbeddingMemory` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        memory_configs: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(memory_configs.into(), scope)
    }
    fn build_impl(
        &self,
        memory_configs: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("CollateTPUEmbeddingMemory", |nd| {
            nd.add_input(memory_configs);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.N {
                nd.set_attr_int("N", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'CollateTPUEmbeddingMemory' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        memory_configs: Vec<crate::Output>,
        scope: &mut crate::Scope,
    ) -> crate::Result<CollateTPUEmbeddingMemoryInst> {
        let op = scope.new_operation("CollateTPUEmbeddingMemory", |builder| {
            builder.add_input_list(&memory_configs);
            builder.set_attr_int("N", memory_configs.clone().len() as i64)?;
            ::std::result::Result::Ok(())
        })?;
        Ok(CollateTPUEmbeddingMemoryInst { op })
    }
}
impl CollateTPUEmbeddingMemoryInst {
    /// Returns the 'merged_memory_config' Output of this 'CollateTPUEmbeddingMemory' operation.
    pub fn merged_memory_config(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns a Vector of memory_configs for 'memory_configs' Input of this CollateTPUEmbeddingMemory operation.
    pub fn memory_configs(&self) -> crate::Result<Vec<crate::Input>> {
        let mut Inputs = vec![];
        for i in 0..self.op.get_attr_int("N")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
}
impl From<CollateTPUEmbeddingMemoryInst> for crate::Operation {
    fn from(inst: CollateTPUEmbeddingMemoryInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `CollateTPUEmbeddingMemory::new().build(memory_configs, scope)`.
pub fn collate_tpuembedding_memory<O0: ::std::convert::Into<crate::Output>>(
    memory_configs: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    CollateTPUEmbeddingMemory::new().build(memory_configs, scope)
}

/// Builder for the `CollectiveAllToAllV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct CollectiveAllToAllV2 {
    T: ::std::option::Option<crate::DataType>,
    communication_hint: ::std::option::Option<::std::string::String>,
    timeout_seconds: ::std::option::Option<f32>,
    Nordering_token: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'CollectiveAllToAllV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct CollectiveAllToAllV2Inst {
    /// An instance of a fully built CollectiveAllToAllV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl CollectiveAllToAllV2 {
    /// Creates a new `CollectiveAllToAllV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `communication_hint` attribute.
    pub fn communication_hint<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.communication_hint = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `timeout_seconds` attribute.
    pub fn timeout_seconds<ArgType: ::std::convert::Into<f32>>(mut self, value: ArgType) -> Self {
        self.timeout_seconds = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Nordering_token` attribute.
    pub fn Nordering_token<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.Nordering_token = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `CollectiveAllToAllV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        group_size: O1,
        group_key: O2,
        instance_key: O3,
        ordering_token: O4,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            input.into(),
            group_size.into(),
            group_key.into(),
            instance_key.into(),
            ordering_token.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        input: crate::Output,
        group_size: crate::Output,
        group_key: crate::Output,
        instance_key: crate::Output,
        ordering_token: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("CollectiveAllToAllV2", |nd| {
            nd.add_input(input);
            nd.add_input(group_size);
            nd.add_input(group_key);
            nd.add_input(instance_key);
            nd.add_input(ordering_token);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.communication_hint {
                nd.set_attr_string("communication_hint", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.timeout_seconds {
                nd.set_attr_float("timeout_seconds", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Nordering_token {
                nd.set_attr_int("Nordering_token", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'CollectiveAllToAllV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        group_size: crate::Output,
        group_key: crate::Output,
        instance_key: crate::Output,
        ordering_token: Vec<crate::Output>,
        scope: &mut crate::Scope,
    ) -> crate::Result<CollectiveAllToAllV2Inst> {
        let op = scope.new_operation("CollectiveAllToAllV2", |builder| {
            builder.add_input(input);
            builder.add_input(group_size);
            builder.add_input(group_key);
            builder.add_input(instance_key);
            builder.add_input_list(&ordering_token);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.communication_hint {
                builder.set_attr_string("communication_hint", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.timeout_seconds {
                builder.set_attr_float("timeout_seconds", *value)?;
            }
            builder.set_attr_int("Nordering_token", ordering_token.clone().len() as i64)?;
            ::std::result::Result::Ok(())
        })?;
        Ok(CollectiveAllToAllV2Inst { op })
    }
}
impl CollectiveAllToAllV2Inst {
    /// Returns the 'data' Output of this 'CollectiveAllToAllV2' operation.
    pub fn data(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'CollectiveAllToAllV2' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'group_size' Input of this 'CollectiveAllToAllV2' operation.
    pub fn group_size(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'group_key' Input of this 'CollectiveAllToAllV2' operation.
    pub fn group_key(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'instance_key' Input of this 'CollectiveAllToAllV2' operation.
    pub fn instance_key(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns a Vector of ordering_token for 'ordering_token' Input of this CollectiveAllToAllV2 operation.
    pub fn ordering_token(&self) -> crate::Result<Vec<crate::Input>> {
        let mut Inputs = vec![];
        for i in 4..self.op.get_attr_int("Nordering_token")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
}
impl From<CollectiveAllToAllV2Inst> for crate::Operation {
    fn from(inst: CollectiveAllToAllV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `CollectiveAllToAllV2::new().build(input, group_size, group_key, instance_key, ordering_token, scope)`.
pub fn collective_all_to_all_v2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
>(
    input: O0,
    group_size: O1,
    group_key: O2,
    instance_key: O3,
    ordering_token: O4,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    CollectiveAllToAllV2::new().build(
        input,
        group_size,
        group_key,
        instance_key,
        ordering_token,
        scope,
    )
}

/// Builder for the `CollectiveAllToAllV3` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct CollectiveAllToAllV3 {
    T: ::std::option::Option<crate::DataType>,
    timeout_seconds: ::std::option::Option<f32>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'CollectiveAllToAllV3' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct CollectiveAllToAllV3Inst {
    /// An instance of a fully built CollectiveAllToAllV3 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl CollectiveAllToAllV3 {
    /// Creates a new `CollectiveAllToAllV3`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `timeout_seconds` attribute.
    pub fn timeout_seconds<ArgType: ::std::convert::Into<f32>>(mut self, value: ArgType) -> Self {
        self.timeout_seconds = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `CollectiveAllToAllV3` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        communicator: O1,
        group_assignment: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            input.into(),
            communicator.into(),
            group_assignment.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        input: crate::Output,
        communicator: crate::Output,
        group_assignment: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("CollectiveAllToAllV3", |nd| {
            nd.add_input(input);
            nd.add_input(communicator);
            nd.add_input(group_assignment);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.timeout_seconds {
                nd.set_attr_float("timeout_seconds", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'CollectiveAllToAllV3' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        communicator: crate::Output,
        group_assignment: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<CollectiveAllToAllV3Inst> {
        let op = scope.new_operation("CollectiveAllToAllV3", |builder| {
            builder.add_input(input);
            builder.add_input(communicator);
            builder.add_input(group_assignment);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.timeout_seconds {
                builder.set_attr_float("timeout_seconds", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(CollectiveAllToAllV3Inst { op })
    }
}
impl CollectiveAllToAllV3Inst {
    /// Returns the 'data' Output of this 'CollectiveAllToAllV3' operation.
    pub fn data(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'CollectiveAllToAllV3' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'communicator' Input of this 'CollectiveAllToAllV3' operation.
    pub fn communicator(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'group_assignment' Input of this 'CollectiveAllToAllV3' operation.
    pub fn group_assignment(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<CollectiveAllToAllV3Inst> for crate::Operation {
    fn from(inst: CollectiveAllToAllV3Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `CollectiveAllToAllV3::new().build(input, communicator, group_assignment, scope)`.
pub fn collective_all_to_all_v3<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    input: O0,
    communicator: O1,
    group_assignment: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    CollectiveAllToAllV3::new().build(input, communicator, group_assignment, scope)
}

/// Builder for the `CollectiveAssignGroupV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct CollectiveAssignGroupV2 {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'CollectiveAssignGroupV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct CollectiveAssignGroupV2Inst {
    /// An instance of a fully built CollectiveAssignGroupV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl CollectiveAssignGroupV2 {
    /// Creates a new `CollectiveAssignGroupV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `CollectiveAssignGroupV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        group_assignment: O0,
        device_index: O1,
        base_key: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            group_assignment.into(),
            device_index.into(),
            base_key.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        group_assignment: crate::Output,
        device_index: crate::Output,
        base_key: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("CollectiveAssignGroupV2", |nd| {
            nd.add_input(group_assignment);
            nd.add_input(device_index);
            nd.add_input(base_key);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'CollectiveAssignGroupV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        group_assignment: crate::Output,
        device_index: crate::Output,
        base_key: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<CollectiveAssignGroupV2Inst> {
        let op = scope.new_operation("CollectiveAssignGroupV2", |builder| {
            builder.add_input(group_assignment);
            builder.add_input(device_index);
            builder.add_input(base_key);
            ::std::result::Result::Ok(())
        })?;
        Ok(CollectiveAssignGroupV2Inst { op })
    }
}
impl CollectiveAssignGroupV2Inst {
    /// Returns the 'group_size' Output of this 'CollectiveAssignGroupV2' operation.
    pub fn group_size(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'group_key' Output of this 'CollectiveAssignGroupV2' operation.
    pub fn group_key(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'group_assignment' Input of this 'CollectiveAssignGroupV2' operation.
    pub fn group_assignment(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'device_index' Input of this 'CollectiveAssignGroupV2' operation.
    pub fn device_index(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'base_key' Input of this 'CollectiveAssignGroupV2' operation.
    pub fn base_key(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<CollectiveAssignGroupV2Inst> for crate::Operation {
    fn from(inst: CollectiveAssignGroupV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `CollectiveAssignGroupV2::new().build(group_assignment, device_index, base_key, scope)`.
pub fn collective_assign_group_v2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    group_assignment: O0,
    device_index: O1,
    base_key: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    CollectiveAssignGroupV2::new().build(group_assignment, device_index, base_key, scope)
}

/// Builder for the `CollectiveBcastRecv` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct CollectiveBcastRecv {
    T: ::std::option::Option<crate::DataType>,
    group_size: ::std::option::Option<i64>,
    group_key: ::std::option::Option<i64>,
    instance_key: ::std::option::Option<i64>,
    shape: ::std::option::Option<crate::Shape>,
    communication_hint: ::std::option::Option<::std::string::String>,
    timeout_seconds: ::std::option::Option<f32>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'CollectiveBcastRecv' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct CollectiveBcastRecvInst {
    /// An instance of a fully built CollectiveBcastRecv Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl CollectiveBcastRecv {
    /// Creates a new `CollectiveBcastRecv`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `group_size` attribute.
    pub fn group_size<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.group_size = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `group_key` attribute.
    pub fn group_key<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.group_key = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `instance_key` attribute.
    pub fn instance_key<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.instance_key = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shape` attribute.
    pub fn shape<ArgType: ::std::convert::Into<crate::Shape>>(mut self, value: ArgType) -> Self {
        self.shape = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `communication_hint` attribute.
    pub fn communication_hint<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.communication_hint = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `timeout_seconds` attribute.
    pub fn timeout_seconds<ArgType: ::std::convert::Into<f32>>(mut self, value: ArgType) -> Self {
        self.timeout_seconds = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `CollectiveBcastRecv` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("CollectiveBcastRecv", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.group_size {
                nd.set_attr_int("group_size", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.group_key {
                nd.set_attr_int("group_key", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.instance_key {
                nd.set_attr_int("instance_key", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shape {
                nd.set_attr_shape("shape", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.communication_hint {
                nd.set_attr_string("communication_hint", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.timeout_seconds {
                nd.set_attr_float("timeout_seconds", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'CollectiveBcastRecv' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        scope: &mut crate::Scope,
    ) -> crate::Result<CollectiveBcastRecvInst> {
        let op = scope.new_operation("CollectiveBcastRecv", |builder| {
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.group_size {
                builder.set_attr_int("group_size", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.group_key {
                builder.set_attr_int("group_key", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.instance_key {
                builder.set_attr_int("instance_key", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shape {
                builder.set_attr_shape("shape", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.communication_hint {
                builder.set_attr_string("communication_hint", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.timeout_seconds {
                builder.set_attr_float("timeout_seconds", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(CollectiveBcastRecvInst { op })
    }
}
impl CollectiveBcastRecvInst {
    /// Returns the 'data' Output of this 'CollectiveBcastRecv' operation.
    pub fn data(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
}
impl From<CollectiveBcastRecvInst> for crate::Operation {
    fn from(inst: CollectiveBcastRecvInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `CollectiveBcastRecv::new().build(scope)`.
pub fn collective_bcast_recv(scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
    CollectiveBcastRecv::new().build(scope)
}

/// Builder for the `CollectiveBcastRecvV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct CollectiveBcastRecvV2 {
    T: ::std::option::Option<crate::DataType>,
    Tshape: ::std::option::Option<crate::DataType>,
    communication_hint: ::std::option::Option<::std::string::String>,
    timeout_seconds: ::std::option::Option<f32>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'CollectiveBcastRecvV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct CollectiveBcastRecvV2Inst {
    /// An instance of a fully built CollectiveBcastRecvV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl CollectiveBcastRecvV2 {
    /// Creates a new `CollectiveBcastRecvV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tshape` attribute.
    pub fn Tshape<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tshape = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `communication_hint` attribute.
    pub fn communication_hint<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.communication_hint = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `timeout_seconds` attribute.
    pub fn timeout_seconds<ArgType: ::std::convert::Into<f32>>(mut self, value: ArgType) -> Self {
        self.timeout_seconds = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `CollectiveBcastRecvV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
    >(
        &self,
        group_size: O0,
        group_key: O1,
        instance_key: O2,
        shape: O3,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            group_size.into(),
            group_key.into(),
            instance_key.into(),
            shape.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        group_size: crate::Output,
        group_key: crate::Output,
        instance_key: crate::Output,
        shape: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("CollectiveBcastRecvV2", |nd| {
            nd.add_input(group_size);
            nd.add_input(group_key);
            nd.add_input(instance_key);
            nd.add_input(shape);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tshape {
                nd.set_attr_type("Tshape", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.communication_hint {
                nd.set_attr_string("communication_hint", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.timeout_seconds {
                nd.set_attr_float("timeout_seconds", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'CollectiveBcastRecvV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        group_size: crate::Output,
        group_key: crate::Output,
        instance_key: crate::Output,
        shape: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<CollectiveBcastRecvV2Inst> {
        let op = scope.new_operation("CollectiveBcastRecvV2", |builder| {
            builder.add_input(group_size);
            builder.add_input(group_key);
            builder.add_input(instance_key);
            builder.add_input(shape);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tshape {
                builder.set_attr_type("Tshape", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.communication_hint {
                builder.set_attr_string("communication_hint", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.timeout_seconds {
                builder.set_attr_float("timeout_seconds", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(CollectiveBcastRecvV2Inst { op })
    }
}
impl CollectiveBcastRecvV2Inst {
    /// Returns the 'data' Output of this 'CollectiveBcastRecvV2' operation.
    pub fn data(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'group_size' Input of this 'CollectiveBcastRecvV2' operation.
    pub fn group_size(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'group_key' Input of this 'CollectiveBcastRecvV2' operation.
    pub fn group_key(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'instance_key' Input of this 'CollectiveBcastRecvV2' operation.
    pub fn instance_key(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'shape' Input of this 'CollectiveBcastRecvV2' operation.
    pub fn shape(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
}
impl From<CollectiveBcastRecvV2Inst> for crate::Operation {
    fn from(inst: CollectiveBcastRecvV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `CollectiveBcastRecvV2::new().build(group_size, group_key, instance_key, shape, scope)`.
pub fn collective_bcast_recv_v2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
>(
    group_size: O0,
    group_key: O1,
    instance_key: O2,
    shape: O3,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    CollectiveBcastRecvV2::new().build(group_size, group_key, instance_key, shape, scope)
}

/// Builder for the `CollectiveBcastSend` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct CollectiveBcastSend {
    T: ::std::option::Option<crate::DataType>,
    group_size: ::std::option::Option<i64>,
    group_key: ::std::option::Option<i64>,
    instance_key: ::std::option::Option<i64>,
    shape: ::std::option::Option<crate::Shape>,
    communication_hint: ::std::option::Option<::std::string::String>,
    timeout_seconds: ::std::option::Option<f32>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'CollectiveBcastSend' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct CollectiveBcastSendInst {
    /// An instance of a fully built CollectiveBcastSend Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl CollectiveBcastSend {
    /// Creates a new `CollectiveBcastSend`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `group_size` attribute.
    pub fn group_size<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.group_size = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `group_key` attribute.
    pub fn group_key<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.group_key = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `instance_key` attribute.
    pub fn instance_key<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.instance_key = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shape` attribute.
    pub fn shape<ArgType: ::std::convert::Into<crate::Shape>>(mut self, value: ArgType) -> Self {
        self.shape = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `communication_hint` attribute.
    pub fn communication_hint<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.communication_hint = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `timeout_seconds` attribute.
    pub fn timeout_seconds<ArgType: ::std::convert::Into<f32>>(mut self, value: ArgType) -> Self {
        self.timeout_seconds = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `CollectiveBcastSend` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("CollectiveBcastSend", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.group_size {
                nd.set_attr_int("group_size", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.group_key {
                nd.set_attr_int("group_key", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.instance_key {
                nd.set_attr_int("instance_key", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shape {
                nd.set_attr_shape("shape", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.communication_hint {
                nd.set_attr_string("communication_hint", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.timeout_seconds {
                nd.set_attr_float("timeout_seconds", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'CollectiveBcastSend' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<CollectiveBcastSendInst> {
        let op = scope.new_operation("CollectiveBcastSend", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.group_size {
                builder.set_attr_int("group_size", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.group_key {
                builder.set_attr_int("group_key", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.instance_key {
                builder.set_attr_int("instance_key", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shape {
                builder.set_attr_shape("shape", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.communication_hint {
                builder.set_attr_string("communication_hint", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.timeout_seconds {
                builder.set_attr_float("timeout_seconds", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(CollectiveBcastSendInst { op })
    }
}
impl CollectiveBcastSendInst {
    /// Returns the 'data' Output of this 'CollectiveBcastSend' operation.
    pub fn data(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'CollectiveBcastSend' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<CollectiveBcastSendInst> for crate::Operation {
    fn from(inst: CollectiveBcastSendInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `CollectiveBcastSend::new().build(input, scope)`.
pub fn collective_bcast_send<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    CollectiveBcastSend::new().build(input, scope)
}

/// Builder for the `CollectiveBcastSendV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct CollectiveBcastSendV2 {
    T: ::std::option::Option<crate::DataType>,
    communication_hint: ::std::option::Option<::std::string::String>,
    timeout_seconds: ::std::option::Option<f32>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'CollectiveBcastSendV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct CollectiveBcastSendV2Inst {
    /// An instance of a fully built CollectiveBcastSendV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl CollectiveBcastSendV2 {
    /// Creates a new `CollectiveBcastSendV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `communication_hint` attribute.
    pub fn communication_hint<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.communication_hint = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `timeout_seconds` attribute.
    pub fn timeout_seconds<ArgType: ::std::convert::Into<f32>>(mut self, value: ArgType) -> Self {
        self.timeout_seconds = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `CollectiveBcastSendV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        group_size: O1,
        group_key: O2,
        instance_key: O3,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            input.into(),
            group_size.into(),
            group_key.into(),
            instance_key.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        input: crate::Output,
        group_size: crate::Output,
        group_key: crate::Output,
        instance_key: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("CollectiveBcastSendV2", |nd| {
            nd.add_input(input);
            nd.add_input(group_size);
            nd.add_input(group_key);
            nd.add_input(instance_key);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.communication_hint {
                nd.set_attr_string("communication_hint", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.timeout_seconds {
                nd.set_attr_float("timeout_seconds", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'CollectiveBcastSendV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        group_size: crate::Output,
        group_key: crate::Output,
        instance_key: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<CollectiveBcastSendV2Inst> {
        let op = scope.new_operation("CollectiveBcastSendV2", |builder| {
            builder.add_input(input);
            builder.add_input(group_size);
            builder.add_input(group_key);
            builder.add_input(instance_key);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.communication_hint {
                builder.set_attr_string("communication_hint", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.timeout_seconds {
                builder.set_attr_float("timeout_seconds", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(CollectiveBcastSendV2Inst { op })
    }
}
impl CollectiveBcastSendV2Inst {
    /// Returns the 'data' Output of this 'CollectiveBcastSendV2' operation.
    pub fn data(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'CollectiveBcastSendV2' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'group_size' Input of this 'CollectiveBcastSendV2' operation.
    pub fn group_size(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'group_key' Input of this 'CollectiveBcastSendV2' operation.
    pub fn group_key(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'instance_key' Input of this 'CollectiveBcastSendV2' operation.
    pub fn instance_key(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
}
impl From<CollectiveBcastSendV2Inst> for crate::Operation {
    fn from(inst: CollectiveBcastSendV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `CollectiveBcastSendV2::new().build(input, group_size, group_key, instance_key, scope)`.
pub fn collective_bcast_send_v2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
>(
    input: O0,
    group_size: O1,
    group_key: O2,
    instance_key: O3,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    CollectiveBcastSendV2::new().build(input, group_size, group_key, instance_key, scope)
}

/// Builder for the `CollectiveGather` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct CollectiveGather {
    T: ::std::option::Option<crate::DataType>,
    group_size: ::std::option::Option<i64>,
    group_key: ::std::option::Option<i64>,
    instance_key: ::std::option::Option<i64>,
    shape: ::std::option::Option<crate::Shape>,
    communication_hint: ::std::option::Option<::std::string::String>,
    timeout_seconds: ::std::option::Option<f32>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'CollectiveGather' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct CollectiveGatherInst {
    /// An instance of a fully built CollectiveGather Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl CollectiveGather {
    /// Creates a new `CollectiveGather`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `group_size` attribute.
    pub fn group_size<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.group_size = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `group_key` attribute.
    pub fn group_key<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.group_key = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `instance_key` attribute.
    pub fn instance_key<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.instance_key = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shape` attribute.
    pub fn shape<ArgType: ::std::convert::Into<crate::Shape>>(mut self, value: ArgType) -> Self {
        self.shape = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `communication_hint` attribute.
    pub fn communication_hint<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.communication_hint = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `timeout_seconds` attribute.
    pub fn timeout_seconds<ArgType: ::std::convert::Into<f32>>(mut self, value: ArgType) -> Self {
        self.timeout_seconds = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `CollectiveGather` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("CollectiveGather", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.group_size {
                nd.set_attr_int("group_size", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.group_key {
                nd.set_attr_int("group_key", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.instance_key {
                nd.set_attr_int("instance_key", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shape {
                nd.set_attr_shape("shape", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.communication_hint {
                nd.set_attr_string("communication_hint", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.timeout_seconds {
                nd.set_attr_float("timeout_seconds", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'CollectiveGather' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<CollectiveGatherInst> {
        let op = scope.new_operation("CollectiveGather", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.group_size {
                builder.set_attr_int("group_size", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.group_key {
                builder.set_attr_int("group_key", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.instance_key {
                builder.set_attr_int("instance_key", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shape {
                builder.set_attr_shape("shape", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.communication_hint {
                builder.set_attr_string("communication_hint", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.timeout_seconds {
                builder.set_attr_float("timeout_seconds", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(CollectiveGatherInst { op })
    }
}
impl CollectiveGatherInst {
    /// Returns the 'data' Output of this 'CollectiveGather' operation.
    pub fn data(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'CollectiveGather' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<CollectiveGatherInst> for crate::Operation {
    fn from(inst: CollectiveGatherInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `CollectiveGather::new().build(input, scope)`.
pub fn collective_gather<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    CollectiveGather::new().build(input, scope)
}

/// Builder for the `CollectiveGatherV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct CollectiveGatherV2 {
    T: ::std::option::Option<crate::DataType>,
    communication_hint: ::std::option::Option<::std::string::String>,
    timeout_seconds: ::std::option::Option<f32>,
    Nordering_token: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'CollectiveGatherV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct CollectiveGatherV2Inst {
    /// An instance of a fully built CollectiveGatherV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl CollectiveGatherV2 {
    /// Creates a new `CollectiveGatherV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `communication_hint` attribute.
    pub fn communication_hint<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.communication_hint = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `timeout_seconds` attribute.
    pub fn timeout_seconds<ArgType: ::std::convert::Into<f32>>(mut self, value: ArgType) -> Self {
        self.timeout_seconds = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Nordering_token` attribute.
    pub fn Nordering_token<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.Nordering_token = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `CollectiveGatherV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        group_size: O1,
        group_key: O2,
        instance_key: O3,
        ordering_token: O4,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            input.into(),
            group_size.into(),
            group_key.into(),
            instance_key.into(),
            ordering_token.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        input: crate::Output,
        group_size: crate::Output,
        group_key: crate::Output,
        instance_key: crate::Output,
        ordering_token: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("CollectiveGatherV2", |nd| {
            nd.add_input(input);
            nd.add_input(group_size);
            nd.add_input(group_key);
            nd.add_input(instance_key);
            nd.add_input(ordering_token);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.communication_hint {
                nd.set_attr_string("communication_hint", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.timeout_seconds {
                nd.set_attr_float("timeout_seconds", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Nordering_token {
                nd.set_attr_int("Nordering_token", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'CollectiveGatherV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        group_size: crate::Output,
        group_key: crate::Output,
        instance_key: crate::Output,
        ordering_token: Vec<crate::Output>,
        scope: &mut crate::Scope,
    ) -> crate::Result<CollectiveGatherV2Inst> {
        let op = scope.new_operation("CollectiveGatherV2", |builder| {
            builder.add_input(input);
            builder.add_input(group_size);
            builder.add_input(group_key);
            builder.add_input(instance_key);
            builder.add_input_list(&ordering_token);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.communication_hint {
                builder.set_attr_string("communication_hint", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.timeout_seconds {
                builder.set_attr_float("timeout_seconds", *value)?;
            }
            builder.set_attr_int("Nordering_token", ordering_token.clone().len() as i64)?;
            ::std::result::Result::Ok(())
        })?;
        Ok(CollectiveGatherV2Inst { op })
    }
}
impl CollectiveGatherV2Inst {
    /// Returns the 'data' Output of this 'CollectiveGatherV2' operation.
    pub fn data(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'CollectiveGatherV2' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'group_size' Input of this 'CollectiveGatherV2' operation.
    pub fn group_size(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'group_key' Input of this 'CollectiveGatherV2' operation.
    pub fn group_key(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'instance_key' Input of this 'CollectiveGatherV2' operation.
    pub fn instance_key(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns a Vector of ordering_token for 'ordering_token' Input of this CollectiveGatherV2 operation.
    pub fn ordering_token(&self) -> crate::Result<Vec<crate::Input>> {
        let mut Inputs = vec![];
        for i in 4..self.op.get_attr_int("Nordering_token")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
}
impl From<CollectiveGatherV2Inst> for crate::Operation {
    fn from(inst: CollectiveGatherV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `CollectiveGatherV2::new().build(input, group_size, group_key, instance_key, ordering_token, scope)`.
pub fn collective_gather_v2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
>(
    input: O0,
    group_size: O1,
    group_key: O2,
    instance_key: O3,
    ordering_token: O4,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    CollectiveGatherV2::new().build(
        input,
        group_size,
        group_key,
        instance_key,
        ordering_token,
        scope,
    )
}

/// Builder for the `CollectiveInitializeCommunicator` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct CollectiveInitializeCommunicator {
    communication_hint: ::std::option::Option<::std::string::String>,
    timeout_seconds: ::std::option::Option<f32>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'CollectiveInitializeCommunicator' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct CollectiveInitializeCommunicatorInst {
    /// An instance of a fully built CollectiveInitializeCommunicator Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl CollectiveInitializeCommunicator {
    /// Creates a new `CollectiveInitializeCommunicator`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `communication_hint` attribute.
    pub fn communication_hint<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.communication_hint = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `timeout_seconds` attribute.
    pub fn timeout_seconds<ArgType: ::std::convert::Into<f32>>(mut self, value: ArgType) -> Self {
        self.timeout_seconds = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `CollectiveInitializeCommunicator` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        group_key: O0,
        rank: O1,
        group_size: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(group_key.into(), rank.into(), group_size.into(), scope)
    }
    fn build_impl(
        &self,
        group_key: crate::Output,
        rank: crate::Output,
        group_size: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("CollectiveInitializeCommunicator", |nd| {
            nd.add_input(group_key);
            nd.add_input(rank);
            nd.add_input(group_size);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.communication_hint {
                nd.set_attr_string("communication_hint", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.timeout_seconds {
                nd.set_attr_float("timeout_seconds", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'CollectiveInitializeCommunicator' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        group_key: crate::Output,
        rank: crate::Output,
        group_size: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<CollectiveInitializeCommunicatorInst> {
        let op = scope.new_operation("CollectiveInitializeCommunicator", |builder| {
            builder.add_input(group_key);
            builder.add_input(rank);
            builder.add_input(group_size);
            if let ::std::option::Option::Some(value) = &self.communication_hint {
                builder.set_attr_string("communication_hint", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.timeout_seconds {
                builder.set_attr_float("timeout_seconds", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(CollectiveInitializeCommunicatorInst { op })
    }
}
impl CollectiveInitializeCommunicatorInst {
    /// Returns the 'communicator' Output of this 'CollectiveInitializeCommunicator' operation.
    pub fn communicator(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'group_key' Input of this 'CollectiveInitializeCommunicator' operation.
    pub fn group_key(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'rank' Input of this 'CollectiveInitializeCommunicator' operation.
    pub fn rank(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'group_size' Input of this 'CollectiveInitializeCommunicator' operation.
    pub fn group_size(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<CollectiveInitializeCommunicatorInst> for crate::Operation {
    fn from(inst: CollectiveInitializeCommunicatorInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `CollectiveInitializeCommunicator::new().build(group_key, rank, group_size, scope)`.
pub fn collective_initialize_communicator<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    group_key: O0,
    rank: O1,
    group_size: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    CollectiveInitializeCommunicator::new().build(group_key, rank, group_size, scope)
}

/// Builder for the `CollectivePermute` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct CollectivePermute {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'CollectivePermute' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct CollectivePermuteInst {
    /// An instance of a fully built CollectivePermute Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl CollectivePermute {
    /// Creates a new `CollectivePermute`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `CollectivePermute` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        source_target_pairs: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), source_target_pairs.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        source_target_pairs: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("CollectivePermute", |nd| {
            nd.add_input(input);
            nd.add_input(source_target_pairs);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'CollectivePermute' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        source_target_pairs: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<CollectivePermuteInst> {
        let op = scope.new_operation("CollectivePermute", |builder| {
            builder.add_input(input);
            builder.add_input(source_target_pairs);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(CollectivePermuteInst { op })
    }
}
impl CollectivePermuteInst {
    /// Returns the 'output' Output of this 'CollectivePermute' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'CollectivePermute' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'source_target_pairs' Input of this 'CollectivePermute' operation.
    pub fn source_target_pairs(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<CollectivePermuteInst> for crate::Operation {
    fn from(inst: CollectivePermuteInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `CollectivePermute::new().build(input, source_target_pairs, scope)`.
pub fn collective_permute<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    input: O0,
    source_target_pairs: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    CollectivePermute::new().build(input, source_target_pairs, scope)
}

/// Builder for the `CollectiveReduce` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct CollectiveReduce {
    T: ::std::option::Option<crate::DataType>,
    group_size: ::std::option::Option<i64>,
    group_key: ::std::option::Option<i64>,
    instance_key: ::std::option::Option<i64>,
    merge_op: ::std::option::Option<::std::string::String>,
    final_op: ::std::option::Option<::std::string::String>,
    subdiv_offsets: ::std::option::Option<::std::vec::Vec<i64>>,
    wait_for: ::std::option::Option<::std::vec::Vec<i64>>,
    communication_hint: ::std::option::Option<::std::string::String>,
    timeout_seconds: ::std::option::Option<f32>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'CollectiveReduce' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct CollectiveReduceInst {
    /// An instance of a fully built CollectiveReduce Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl CollectiveReduce {
    /// Creates a new `CollectiveReduce`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `group_size` attribute.
    pub fn group_size<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.group_size = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `group_key` attribute.
    pub fn group_key<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.group_key = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `instance_key` attribute.
    pub fn instance_key<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.instance_key = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `merge_op` attribute.
    pub fn merge_op<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.merge_op = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `final_op` attribute.
    pub fn final_op<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.final_op = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `subdiv_offsets` attribute.
    pub fn subdiv_offsets<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.subdiv_offsets = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `wait_for` attribute.
    pub fn wait_for<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.wait_for = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `communication_hint` attribute.
    pub fn communication_hint<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.communication_hint = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `timeout_seconds` attribute.
    pub fn timeout_seconds<ArgType: ::std::convert::Into<f32>>(mut self, value: ArgType) -> Self {
        self.timeout_seconds = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `CollectiveReduce` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("CollectiveReduce", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.group_size {
                nd.set_attr_int("group_size", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.group_key {
                nd.set_attr_int("group_key", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.instance_key {
                nd.set_attr_int("instance_key", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.merge_op {
                nd.set_attr_string("merge_op", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.final_op {
                nd.set_attr_string("final_op", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.subdiv_offsets {
                nd.set_attr_int_list("subdiv_offsets", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.wait_for {
                nd.set_attr_int_list("wait_for", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.communication_hint {
                nd.set_attr_string("communication_hint", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.timeout_seconds {
                nd.set_attr_float("timeout_seconds", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'CollectiveReduce' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<CollectiveReduceInst> {
        let op = scope.new_operation("CollectiveReduce", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.group_size {
                builder.set_attr_int("group_size", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.group_key {
                builder.set_attr_int("group_key", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.instance_key {
                builder.set_attr_int("instance_key", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.merge_op {
                builder.set_attr_string("merge_op", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.final_op {
                builder.set_attr_string("final_op", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.subdiv_offsets {
                builder.set_attr_int_list("subdiv_offsets", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.wait_for {
                builder.set_attr_int_list("wait_for", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.communication_hint {
                builder.set_attr_string("communication_hint", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.timeout_seconds {
                builder.set_attr_float("timeout_seconds", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(CollectiveReduceInst { op })
    }
}
impl CollectiveReduceInst {
    /// Returns the 'data' Output of this 'CollectiveReduce' operation.
    pub fn data(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'CollectiveReduce' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<CollectiveReduceInst> for crate::Operation {
    fn from(inst: CollectiveReduceInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `CollectiveReduce::new().build(input, scope)`.
pub fn collective_reduce<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    CollectiveReduce::new().build(input, scope)
}

/// Builder for the `CollectiveReduceScatterV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct CollectiveReduceScatterV2 {
    T: ::std::option::Option<crate::DataType>,
    merge_op: ::std::option::Option<::std::string::String>,
    final_op: ::std::option::Option<::std::string::String>,
    communication_hint: ::std::option::Option<::std::string::String>,
    timeout_seconds: ::std::option::Option<f32>,
    Nordering_token: ::std::option::Option<i64>,
    max_subdivs_per_device: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'CollectiveReduceScatterV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct CollectiveReduceScatterV2Inst {
    /// An instance of a fully built CollectiveReduceScatterV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl CollectiveReduceScatterV2 {
    /// Creates a new `CollectiveReduceScatterV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `merge_op` attribute.
    pub fn merge_op<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.merge_op = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `final_op` attribute.
    pub fn final_op<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.final_op = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `communication_hint` attribute.
    pub fn communication_hint<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.communication_hint = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `timeout_seconds` attribute.
    pub fn timeout_seconds<ArgType: ::std::convert::Into<f32>>(mut self, value: ArgType) -> Self {
        self.timeout_seconds = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Nordering_token` attribute.
    pub fn Nordering_token<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.Nordering_token = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `max_subdivs_per_device` attribute.
    pub fn max_subdivs_per_device<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.max_subdivs_per_device = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `CollectiveReduceScatterV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        group_size: O1,
        group_key: O2,
        instance_key: O3,
        ordering_token: O4,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            input.into(),
            group_size.into(),
            group_key.into(),
            instance_key.into(),
            ordering_token.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        input: crate::Output,
        group_size: crate::Output,
        group_key: crate::Output,
        instance_key: crate::Output,
        ordering_token: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("CollectiveReduceScatterV2", |nd| {
            nd.add_input(input);
            nd.add_input(group_size);
            nd.add_input(group_key);
            nd.add_input(instance_key);
            nd.add_input(ordering_token);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.merge_op {
                nd.set_attr_string("merge_op", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.final_op {
                nd.set_attr_string("final_op", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.communication_hint {
                nd.set_attr_string("communication_hint", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.timeout_seconds {
                nd.set_attr_float("timeout_seconds", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Nordering_token {
                nd.set_attr_int("Nordering_token", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.max_subdivs_per_device {
                nd.set_attr_int("max_subdivs_per_device", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'CollectiveReduceScatterV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        group_size: crate::Output,
        group_key: crate::Output,
        instance_key: crate::Output,
        ordering_token: Vec<crate::Output>,
        scope: &mut crate::Scope,
    ) -> crate::Result<CollectiveReduceScatterV2Inst> {
        let op = scope.new_operation("CollectiveReduceScatterV2", |builder| {
            builder.add_input(input);
            builder.add_input(group_size);
            builder.add_input(group_key);
            builder.add_input(instance_key);
            builder.add_input_list(&ordering_token);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.merge_op {
                builder.set_attr_string("merge_op", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.final_op {
                builder.set_attr_string("final_op", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.communication_hint {
                builder.set_attr_string("communication_hint", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.timeout_seconds {
                builder.set_attr_float("timeout_seconds", *value)?;
            }
            builder.set_attr_int("Nordering_token", ordering_token.clone().len() as i64)?;
            if let ::std::option::Option::Some(value) = &self.max_subdivs_per_device {
                builder.set_attr_int("max_subdivs_per_device", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(CollectiveReduceScatterV2Inst { op })
    }
}
impl CollectiveReduceScatterV2Inst {
    /// Returns the 'data' Output of this 'CollectiveReduceScatterV2' operation.
    pub fn data(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'CollectiveReduceScatterV2' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'group_size' Input of this 'CollectiveReduceScatterV2' operation.
    pub fn group_size(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'group_key' Input of this 'CollectiveReduceScatterV2' operation.
    pub fn group_key(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'instance_key' Input of this 'CollectiveReduceScatterV2' operation.
    pub fn instance_key(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns a Vector of ordering_token for 'ordering_token' Input of this CollectiveReduceScatterV2 operation.
    pub fn ordering_token(&self) -> crate::Result<Vec<crate::Input>> {
        let mut Inputs = vec![];
        for i in 4..self.op.get_attr_int("Nordering_token")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
}
impl From<CollectiveReduceScatterV2Inst> for crate::Operation {
    fn from(inst: CollectiveReduceScatterV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `CollectiveReduceScatterV2::new().build(input, group_size, group_key, instance_key, ordering_token, scope)`.
pub fn collective_reduce_scatter_v2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
>(
    input: O0,
    group_size: O1,
    group_key: O2,
    instance_key: O3,
    ordering_token: O4,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    CollectiveReduceScatterV2::new().build(
        input,
        group_size,
        group_key,
        instance_key,
        ordering_token,
        scope,
    )
}

/// Builder for the `CollectiveReduceV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct CollectiveReduceV2 {
    T: ::std::option::Option<crate::DataType>,
    merge_op: ::std::option::Option<::std::string::String>,
    final_op: ::std::option::Option<::std::string::String>,
    communication_hint: ::std::option::Option<::std::string::String>,
    timeout_seconds: ::std::option::Option<f32>,
    Nordering_token: ::std::option::Option<i64>,
    max_subdivs_per_device: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'CollectiveReduceV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct CollectiveReduceV2Inst {
    /// An instance of a fully built CollectiveReduceV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl CollectiveReduceV2 {
    /// Creates a new `CollectiveReduceV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `merge_op` attribute.
    pub fn merge_op<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.merge_op = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `final_op` attribute.
    pub fn final_op<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.final_op = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `communication_hint` attribute.
    pub fn communication_hint<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.communication_hint = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `timeout_seconds` attribute.
    pub fn timeout_seconds<ArgType: ::std::convert::Into<f32>>(mut self, value: ArgType) -> Self {
        self.timeout_seconds = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Nordering_token` attribute.
    pub fn Nordering_token<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.Nordering_token = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `max_subdivs_per_device` attribute.
    pub fn max_subdivs_per_device<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.max_subdivs_per_device = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `CollectiveReduceV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        group_size: O1,
        group_key: O2,
        instance_key: O3,
        ordering_token: O4,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            input.into(),
            group_size.into(),
            group_key.into(),
            instance_key.into(),
            ordering_token.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        input: crate::Output,
        group_size: crate::Output,
        group_key: crate::Output,
        instance_key: crate::Output,
        ordering_token: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("CollectiveReduceV2", |nd| {
            nd.add_input(input);
            nd.add_input(group_size);
            nd.add_input(group_key);
            nd.add_input(instance_key);
            nd.add_input(ordering_token);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.merge_op {
                nd.set_attr_string("merge_op", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.final_op {
                nd.set_attr_string("final_op", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.communication_hint {
                nd.set_attr_string("communication_hint", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.timeout_seconds {
                nd.set_attr_float("timeout_seconds", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Nordering_token {
                nd.set_attr_int("Nordering_token", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.max_subdivs_per_device {
                nd.set_attr_int("max_subdivs_per_device", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'CollectiveReduceV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        group_size: crate::Output,
        group_key: crate::Output,
        instance_key: crate::Output,
        ordering_token: Vec<crate::Output>,
        scope: &mut crate::Scope,
    ) -> crate::Result<CollectiveReduceV2Inst> {
        let op = scope.new_operation("CollectiveReduceV2", |builder| {
            builder.add_input(input);
            builder.add_input(group_size);
            builder.add_input(group_key);
            builder.add_input(instance_key);
            builder.add_input_list(&ordering_token);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.merge_op {
                builder.set_attr_string("merge_op", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.final_op {
                builder.set_attr_string("final_op", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.communication_hint {
                builder.set_attr_string("communication_hint", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.timeout_seconds {
                builder.set_attr_float("timeout_seconds", *value)?;
            }
            builder.set_attr_int("Nordering_token", ordering_token.clone().len() as i64)?;
            if let ::std::option::Option::Some(value) = &self.max_subdivs_per_device {
                builder.set_attr_int("max_subdivs_per_device", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(CollectiveReduceV2Inst { op })
    }
}
impl CollectiveReduceV2Inst {
    /// Returns the 'data' Output of this 'CollectiveReduceV2' operation.
    pub fn data(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'CollectiveReduceV2' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'group_size' Input of this 'CollectiveReduceV2' operation.
    pub fn group_size(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'group_key' Input of this 'CollectiveReduceV2' operation.
    pub fn group_key(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'instance_key' Input of this 'CollectiveReduceV2' operation.
    pub fn instance_key(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns a Vector of ordering_token for 'ordering_token' Input of this CollectiveReduceV2 operation.
    pub fn ordering_token(&self) -> crate::Result<Vec<crate::Input>> {
        let mut Inputs = vec![];
        for i in 4..self.op.get_attr_int("Nordering_token")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
}
impl From<CollectiveReduceV2Inst> for crate::Operation {
    fn from(inst: CollectiveReduceV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `CollectiveReduceV2::new().build(input, group_size, group_key, instance_key, ordering_token, scope)`.
pub fn collective_reduce_v2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
>(
    input: O0,
    group_size: O1,
    group_key: O2,
    instance_key: O3,
    ordering_token: O4,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    CollectiveReduceV2::new().build(
        input,
        group_size,
        group_key,
        instance_key,
        ordering_token,
        scope,
    )
}

/// Builder for the `CollectiveReduceV3` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct CollectiveReduceV3 {
    T: ::std::option::Option<crate::DataType>,
    reduction: ::std::option::Option<::std::string::String>,
    timeout_seconds: ::std::option::Option<f32>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'CollectiveReduceV3' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct CollectiveReduceV3Inst {
    /// An instance of a fully built CollectiveReduceV3 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl CollectiveReduceV3 {
    /// Creates a new `CollectiveReduceV3`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `reduction` attribute.
    pub fn reduction<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.reduction = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `timeout_seconds` attribute.
    pub fn timeout_seconds<ArgType: ::std::convert::Into<f32>>(mut self, value: ArgType) -> Self {
        self.timeout_seconds = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `CollectiveReduceV3` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        communicator: O1,
        group_assignment: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            input.into(),
            communicator.into(),
            group_assignment.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        input: crate::Output,
        communicator: crate::Output,
        group_assignment: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("CollectiveReduceV3", |nd| {
            nd.add_input(input);
            nd.add_input(communicator);
            nd.add_input(group_assignment);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.reduction {
                nd.set_attr_string("reduction", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.timeout_seconds {
                nd.set_attr_float("timeout_seconds", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'CollectiveReduceV3' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        communicator: crate::Output,
        group_assignment: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<CollectiveReduceV3Inst> {
        let op = scope.new_operation("CollectiveReduceV3", |builder| {
            builder.add_input(input);
            builder.add_input(communicator);
            builder.add_input(group_assignment);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.reduction {
                builder.set_attr_string("reduction", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.timeout_seconds {
                builder.set_attr_float("timeout_seconds", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(CollectiveReduceV3Inst { op })
    }
}
impl CollectiveReduceV3Inst {
    /// Returns the 'data' Output of this 'CollectiveReduceV3' operation.
    pub fn data(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'CollectiveReduceV3' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'communicator' Input of this 'CollectiveReduceV3' operation.
    pub fn communicator(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'group_assignment' Input of this 'CollectiveReduceV3' operation.
    pub fn group_assignment(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<CollectiveReduceV3Inst> for crate::Operation {
    fn from(inst: CollectiveReduceV3Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `CollectiveReduceV3::new().build(input, communicator, group_assignment, scope)`.
pub fn collective_reduce_v3<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    input: O0,
    communicator: O1,
    group_assignment: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    CollectiveReduceV3::new().build(input, communicator, group_assignment, scope)
}

/// Builder for the `CombinedNonMaxSuppression` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct CombinedNonMaxSuppression {
    pad_per_class: ::std::option::Option<bool>,
    clip_boxes: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'CombinedNonMaxSuppression' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct CombinedNonMaxSuppressionInst {
    /// An instance of a fully built CombinedNonMaxSuppression Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl CombinedNonMaxSuppression {
    /// Creates a new `CombinedNonMaxSuppression`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `pad_per_class` attribute.
    pub fn pad_per_class<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.pad_per_class = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `clip_boxes` attribute.
    pub fn clip_boxes<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.clip_boxes = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `CombinedNonMaxSuppression` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
    >(
        &self,
        boxes: O0,
        scores: O1,
        max_output_size_per_class: O2,
        max_total_size: O3,
        iou_threshold: O4,
        score_threshold: O5,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            boxes.into(),
            scores.into(),
            max_output_size_per_class.into(),
            max_total_size.into(),
            iou_threshold.into(),
            score_threshold.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        boxes: crate::Output,
        scores: crate::Output,
        max_output_size_per_class: crate::Output,
        max_total_size: crate::Output,
        iou_threshold: crate::Output,
        score_threshold: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("CombinedNonMaxSuppression", |nd| {
            nd.add_input(boxes);
            nd.add_input(scores);
            nd.add_input(max_output_size_per_class);
            nd.add_input(max_total_size);
            nd.add_input(iou_threshold);
            nd.add_input(score_threshold);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.pad_per_class {
                nd.set_attr_bool("pad_per_class", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.clip_boxes {
                nd.set_attr_bool("clip_boxes", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'CombinedNonMaxSuppression' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        boxes: crate::Output,
        scores: crate::Output,
        max_output_size_per_class: crate::Output,
        max_total_size: crate::Output,
        iou_threshold: crate::Output,
        score_threshold: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<CombinedNonMaxSuppressionInst> {
        let op = scope.new_operation("CombinedNonMaxSuppression", |builder| {
            builder.add_input(boxes);
            builder.add_input(scores);
            builder.add_input(max_output_size_per_class);
            builder.add_input(max_total_size);
            builder.add_input(iou_threshold);
            builder.add_input(score_threshold);
            if let ::std::option::Option::Some(value) = &self.pad_per_class {
                builder.set_attr_bool("pad_per_class", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.clip_boxes {
                builder.set_attr_bool("clip_boxes", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(CombinedNonMaxSuppressionInst { op })
    }
}
impl CombinedNonMaxSuppressionInst {
    /// Returns the 'nmsed_boxes' Output of this 'CombinedNonMaxSuppression' operation.
    pub fn nmsed_boxes(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'nmsed_scores' Output of this 'CombinedNonMaxSuppression' operation.
    pub fn nmsed_scores(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'nmsed_classes' Output of this 'CombinedNonMaxSuppression' operation.
    pub fn nmsed_classes(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns the 'valid_detections' Output of this 'CombinedNonMaxSuppression' operation.
    pub fn valid_detections(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 3,
        }
    }
    /// Returns the 'boxes' Input of this 'CombinedNonMaxSuppression' operation.
    pub fn boxes(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'scores' Input of this 'CombinedNonMaxSuppression' operation.
    pub fn scores(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'max_output_size_per_class' Input of this 'CombinedNonMaxSuppression' operation.
    pub fn max_output_size_per_class(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'max_total_size' Input of this 'CombinedNonMaxSuppression' operation.
    pub fn max_total_size(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'iou_threshold' Input of this 'CombinedNonMaxSuppression' operation.
    pub fn iou_threshold(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
    /// Returns the 'score_threshold' Input of this 'CombinedNonMaxSuppression' operation.
    pub fn score_threshold(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 5,
        }
    }
}
impl From<CombinedNonMaxSuppressionInst> for crate::Operation {
    fn from(inst: CombinedNonMaxSuppressionInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `CombinedNonMaxSuppression::new().build(boxes, scores, max_output_size_per_class, max_total_size, iou_threshold, score_threshold, scope)`.
pub fn combined_non_max_suppression<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
>(
    boxes: O0,
    scores: O1,
    max_output_size_per_class: O2,
    max_total_size: O3,
    iou_threshold: O4,
    score_threshold: O5,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    CombinedNonMaxSuppression::new().build(
        boxes,
        scores,
        max_output_size_per_class,
        max_total_size,
        iou_threshold,
        score_threshold,
        scope,
    )
}

/// Builder for the `Complex` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Complex {
    T: ::std::option::Option<crate::DataType>,
    Tout: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Complex' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ComplexInst {
    /// An instance of a fully built Complex Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Complex {
    /// Creates a new `Complex`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tout` attribute.
    pub fn Tout<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Tout = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Complex` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        real: O0,
        imag: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(real.into(), imag.into(), scope)
    }
    fn build_impl(
        &self,
        real: crate::Output,
        imag: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Complex", |nd| {
            nd.add_input(real);
            nd.add_input(imag);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tout {
                nd.set_attr_type("Tout", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Complex' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        real: crate::Output,
        imag: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ComplexInst> {
        let op = scope.new_operation("Complex", |builder| {
            builder.add_input(real);
            builder.add_input(imag);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tout {
                builder.set_attr_type("Tout", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ComplexInst { op })
    }
}
impl ComplexInst {
    /// Returns the 'out' Output of this 'Complex' operation.
    pub fn out(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'real' Input of this 'Complex' operation.
    pub fn real(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'imag' Input of this 'Complex' operation.
    pub fn imag(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<ComplexInst> for crate::Operation {
    fn from(inst: ComplexInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Complex::new().build(real, imag, scope)`.
pub fn complex<O0: ::std::convert::Into<crate::Output>, O1: ::std::convert::Into<crate::Output>>(
    real: O0,
    imag: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Complex::new().build(real, imag, scope)
}

/// Builder for the `ComplexAbs` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ComplexAbs {
    T: ::std::option::Option<crate::DataType>,
    Tout: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ComplexAbs' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ComplexAbsInst {
    /// An instance of a fully built ComplexAbs Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ComplexAbs {
    /// Creates a new `ComplexAbs`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tout` attribute.
    pub fn Tout<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Tout = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ComplexAbs` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        x: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ComplexAbs", |nd| {
            nd.add_input(x);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tout {
                nd.set_attr_type("Tout", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ComplexAbs' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ComplexAbsInst> {
        let op = scope.new_operation("ComplexAbs", |builder| {
            builder.add_input(x);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tout {
                builder.set_attr_type("Tout", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ComplexAbsInst { op })
    }
}
impl ComplexAbsInst {
    /// Returns the 'y' Output of this 'ComplexAbs' operation.
    pub fn y(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'ComplexAbs' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<ComplexAbsInst> for crate::Operation {
    fn from(inst: ComplexAbsInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ComplexAbs::new().build(x, scope)`.
pub fn complex_abs<O0: ::std::convert::Into<crate::Output>>(
    x: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ComplexAbs::new().build(x, scope)
}

/// Builder for the `CompositeTensorVariantFromComponents` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct CompositeTensorVariantFromComponents {
    metadata: ::std::option::Option<::std::string::String>,
    Tcomponents: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'CompositeTensorVariantFromComponents' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct CompositeTensorVariantFromComponentsInst {
    /// An instance of a fully built CompositeTensorVariantFromComponents Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl CompositeTensorVariantFromComponents {
    /// Creates a new `CompositeTensorVariantFromComponents`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `metadata` attribute.
    pub fn metadata<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.metadata = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tcomponents` attribute.
    pub fn Tcomponents<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tcomponents = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `CompositeTensorVariantFromComponents` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        components: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(components.into(), scope)
    }
    fn build_impl(
        &self,
        components: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("CompositeTensorVariantFromComponents", |nd| {
            nd.add_input(components);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.metadata {
                nd.set_attr_string("metadata", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tcomponents {
                nd.set_attr_type_list("Tcomponents", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'CompositeTensorVariantFromComponents' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        components: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<CompositeTensorVariantFromComponentsInst> {
        let op = scope.new_operation("CompositeTensorVariantFromComponents", |builder| {
            builder.add_input(components);
            if let ::std::option::Option::Some(value) = &self.metadata {
                builder.set_attr_string("metadata", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tcomponents {
                builder.set_attr_type_list("Tcomponents", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(CompositeTensorVariantFromComponentsInst { op })
    }
}
impl CompositeTensorVariantFromComponentsInst {
    /// Returns the 'encoded' Output of this 'CompositeTensorVariantFromComponents' operation.
    pub fn encoded(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'components' Input of this 'CompositeTensorVariantFromComponents' operation.
    pub fn components(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<CompositeTensorVariantFromComponentsInst> for crate::Operation {
    fn from(inst: CompositeTensorVariantFromComponentsInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `CompositeTensorVariantFromComponents::new().build(components, scope)`.
pub fn composite_tensor_variant_from_components<O0: ::std::convert::Into<crate::Output>>(
    components: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    CompositeTensorVariantFromComponents::new().build(components, scope)
}

/// Builder for the `CompositeTensorVariantToComponents` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct CompositeTensorVariantToComponents {
    metadata: ::std::option::Option<::std::string::String>,
    Tcomponents: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'CompositeTensorVariantToComponents' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct CompositeTensorVariantToComponentsInst {
    /// An instance of a fully built CompositeTensorVariantToComponents Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl CompositeTensorVariantToComponents {
    /// Creates a new `CompositeTensorVariantToComponents`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `metadata` attribute.
    pub fn metadata<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.metadata = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tcomponents` attribute.
    pub fn Tcomponents<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tcomponents = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `CompositeTensorVariantToComponents` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        encoded: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(encoded.into(), scope)
    }
    fn build_impl(
        &self,
        encoded: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("CompositeTensorVariantToComponents", |nd| {
            nd.add_input(encoded);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.metadata {
                nd.set_attr_string("metadata", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tcomponents {
                nd.set_attr_type_list("Tcomponents", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'CompositeTensorVariantToComponents' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        encoded: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<CompositeTensorVariantToComponentsInst> {
        let op = scope.new_operation("CompositeTensorVariantToComponents", |builder| {
            builder.add_input(encoded);
            if let ::std::option::Option::Some(value) = &self.metadata {
                builder.set_attr_string("metadata", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tcomponents {
                builder.set_attr_type_list("Tcomponents", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(CompositeTensorVariantToComponentsInst { op })
    }
}
impl CompositeTensorVariantToComponentsInst {
    /// Returns the 'components' Output of this 'CompositeTensorVariantToComponents' operation.
    pub fn components(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'encoded' Input of this 'CompositeTensorVariantToComponents' operation.
    pub fn encoded(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<CompositeTensorVariantToComponentsInst> for crate::Operation {
    fn from(inst: CompositeTensorVariantToComponentsInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `CompositeTensorVariantToComponents::new().build(encoded, scope)`.
pub fn composite_tensor_variant_to_components<O0: ::std::convert::Into<crate::Output>>(
    encoded: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    CompositeTensorVariantToComponents::new().build(encoded, scope)
}

/// Builder for the `CompressElement` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct CompressElement {
    input_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'CompressElement' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct CompressElementInst {
    /// An instance of a fully built CompressElement Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl CompressElement {
    /// Creates a new `CompressElement`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `input_types` attribute.
    pub fn input_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.input_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `CompressElement` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        components: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(components.into(), scope)
    }
    fn build_impl(
        &self,
        components: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("CompressElement", |nd| {
            nd.add_input(components);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.input_types {
                nd.set_attr_type_list("input_types", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'CompressElement' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        components: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<CompressElementInst> {
        let op = scope.new_operation("CompressElement", |builder| {
            builder.add_input(components);
            if let ::std::option::Option::Some(value) = &self.input_types {
                builder.set_attr_type_list("input_types", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(CompressElementInst { op })
    }
}
impl CompressElementInst {
    /// Returns the 'compressed' Output of this 'CompressElement' operation.
    pub fn compressed(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'components' Input of this 'CompressElement' operation.
    pub fn components(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<CompressElementInst> for crate::Operation {
    fn from(inst: CompressElementInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `CompressElement::new().build(components, scope)`.
pub fn compress_element<O0: ::std::convert::Into<crate::Output>>(
    components: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    CompressElement::new().build(components, scope)
}

/// Builder for the `ComputeAccidentalHits` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ComputeAccidentalHits {
    num_true: ::std::option::Option<i64>,
    seed: ::std::option::Option<i64>,
    seed2: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ComputeAccidentalHits' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ComputeAccidentalHitsInst {
    /// An instance of a fully built ComputeAccidentalHits Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ComputeAccidentalHits {
    /// Creates a new `ComputeAccidentalHits`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `num_true` attribute.
    pub fn num_true<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.num_true = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `seed` attribute.
    pub fn seed<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.seed = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `seed2` attribute.
    pub fn seed2<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.seed2 = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ComputeAccidentalHits` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        true_classes: O0,
        sampled_candidates: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(true_classes.into(), sampled_candidates.into(), scope)
    }
    fn build_impl(
        &self,
        true_classes: crate::Output,
        sampled_candidates: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ComputeAccidentalHits", |nd| {
            nd.add_input(true_classes);
            nd.add_input(sampled_candidates);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.num_true {
                nd.set_attr_int("num_true", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed {
                nd.set_attr_int("seed", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed2 {
                nd.set_attr_int("seed2", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ComputeAccidentalHits' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        true_classes: crate::Output,
        sampled_candidates: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ComputeAccidentalHitsInst> {
        let op = scope.new_operation("ComputeAccidentalHits", |builder| {
            builder.add_input(true_classes);
            builder.add_input(sampled_candidates);
            if let ::std::option::Option::Some(value) = &self.num_true {
                builder.set_attr_int("num_true", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed {
                builder.set_attr_int("seed", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed2 {
                builder.set_attr_int("seed2", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ComputeAccidentalHitsInst { op })
    }
}
impl ComputeAccidentalHitsInst {
    /// Returns the 'indices' Output of this 'ComputeAccidentalHits' operation.
    pub fn indices(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'ids' Output of this 'ComputeAccidentalHits' operation.
    pub fn ids(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'weights' Output of this 'ComputeAccidentalHits' operation.
    pub fn weights(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns the 'true_classes' Input of this 'ComputeAccidentalHits' operation.
    pub fn true_classes(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'sampled_candidates' Input of this 'ComputeAccidentalHits' operation.
    pub fn sampled_candidates(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<ComputeAccidentalHitsInst> for crate::Operation {
    fn from(inst: ComputeAccidentalHitsInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ComputeAccidentalHits::new().build(true_classes, sampled_candidates, scope)`.
pub fn compute_accidental_hits<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    true_classes: O0,
    sampled_candidates: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ComputeAccidentalHits::new().build(true_classes, sampled_candidates, scope)
}

/// Builder for the `ComputeBatchSize` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ComputeBatchSize {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ComputeBatchSize' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ComputeBatchSizeInst {
    /// An instance of a fully built ComputeBatchSize Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ComputeBatchSize {
    /// Creates a new `ComputeBatchSize`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ComputeBatchSize` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input_dataset: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input_dataset.into(), scope)
    }
    fn build_impl(
        &self,
        input_dataset: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ComputeBatchSize", |nd| {
            nd.add_input(input_dataset);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ComputeBatchSize' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_dataset: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ComputeBatchSizeInst> {
        let op = scope.new_operation("ComputeBatchSize", |builder| {
            builder.add_input(input_dataset);
            ::std::result::Result::Ok(())
        })?;
        Ok(ComputeBatchSizeInst { op })
    }
}
impl ComputeBatchSizeInst {
    /// Returns the 'batch_size' Output of this 'ComputeBatchSize' operation.
    pub fn batch_size(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_dataset' Input of this 'ComputeBatchSize' operation.
    pub fn input_dataset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<ComputeBatchSizeInst> for crate::Operation {
    fn from(inst: ComputeBatchSizeInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ComputeBatchSize::new().build(input_dataset, scope)`.
pub fn compute_batch_size<O0: ::std::convert::Into<crate::Output>>(
    input_dataset: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ComputeBatchSize::new().build(input_dataset, scope)
}

/// Builder for the `ComputeDedupDataTupleMask` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ComputeDedupDataTupleMask {
    config: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ComputeDedupDataTupleMask' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ComputeDedupDataTupleMaskInst {
    /// An instance of a fully built ComputeDedupDataTupleMask Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ComputeDedupDataTupleMask {
    /// Creates a new `ComputeDedupDataTupleMask`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `config` attribute.
    pub fn config<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.config = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ComputeDedupDataTupleMask` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("ComputeDedupDataTupleMask", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.config {
                nd.set_attr_string("config", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ComputeDedupDataTupleMask' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        scope: &mut crate::Scope,
    ) -> crate::Result<ComputeDedupDataTupleMaskInst> {
        let op = scope.new_operation("ComputeDedupDataTupleMask", |builder| {
            if let ::std::option::Option::Some(value) = &self.config {
                builder.set_attr_string("config", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ComputeDedupDataTupleMaskInst { op })
    }
}
impl ComputeDedupDataTupleMaskInst {
    /// Returns the 'output_shape' Output of this 'ComputeDedupDataTupleMask' operation.
    pub fn output_shape(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
}
impl From<ComputeDedupDataTupleMaskInst> for crate::Operation {
    fn from(inst: ComputeDedupDataTupleMaskInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ComputeDedupDataTupleMask::new().build(scope)`.
pub fn compute_dedup_data_tuple_mask(scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
    ComputeDedupDataTupleMask::new().build(scope)
}

/// Builder for the `Concat` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Concat {
    N: ::std::option::Option<i64>,
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Concat' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ConcatInst {
    /// An instance of a fully built Concat Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Concat {
    /// Creates a new `Concat`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `N` attribute.
    pub fn N<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.N = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Concat` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        concat_dim: O0,
        values: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(concat_dim.into(), values.into(), scope)
    }
    fn build_impl(
        &self,
        concat_dim: crate::Output,
        values: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Concat", |nd| {
            nd.add_input(concat_dim);
            nd.add_input(values);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.N {
                nd.set_attr_int("N", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Concat' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        concat_dim: crate::Output,
        values: Vec<crate::Output>,
        scope: &mut crate::Scope,
    ) -> crate::Result<ConcatInst> {
        let op = scope.new_operation("Concat", |builder| {
            builder.add_input(concat_dim);
            builder.add_input_list(&values);
            builder.set_attr_int("N", values.clone().len() as i64)?;
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ConcatInst { op })
    }
}
impl ConcatInst {
    /// Returns the 'output' Output of this 'Concat' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'concat_dim' Input of this 'Concat' operation.
    pub fn concat_dim(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns a Vector of values for 'values' Input of this Concat operation.
    pub fn values(&self) -> crate::Result<Vec<crate::Input>> {
        let mut Inputs = vec![];
        for i in 1..self.op.get_attr_int("N")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
}
impl From<ConcatInst> for crate::Operation {
    fn from(inst: ConcatInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Concat::new().build(concat_dim, values, scope)`.
pub fn concat<O0: ::std::convert::Into<crate::Output>, O1: ::std::convert::Into<crate::Output>>(
    concat_dim: O0,
    values: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Concat::new().build(concat_dim, values, scope)
}

/// Builder for the `ConcatOffset` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ConcatOffset {
    N: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ConcatOffset' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ConcatOffsetInst {
    /// An instance of a fully built ConcatOffset Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ConcatOffset {
    /// Creates a new `ConcatOffset`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `N` attribute.
    pub fn N<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.N = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ConcatOffset` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        concat_dim: O0,
        shape: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(concat_dim.into(), shape.into(), scope)
    }
    fn build_impl(
        &self,
        concat_dim: crate::Output,
        shape: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ConcatOffset", |nd| {
            nd.add_input(concat_dim);
            nd.add_input(shape);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.N {
                nd.set_attr_int("N", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ConcatOffset' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        concat_dim: crate::Output,
        shape: Vec<crate::Output>,
        scope: &mut crate::Scope,
    ) -> crate::Result<ConcatOffsetInst> {
        let op = scope.new_operation("ConcatOffset", |builder| {
            builder.add_input(concat_dim);
            builder.add_input_list(&shape);
            builder.set_attr_int("N", shape.clone().len() as i64)?;
            ::std::result::Result::Ok(())
        })?;
        Ok(ConcatOffsetInst { op })
    }
}
impl ConcatOffsetInst {
    /// Returns a Vector of offset for 'offset' Output of this ConcatOffset operation.
    pub fn offset(&self) -> crate::Result<Vec<crate::Output>> {
        let mut Outputs = vec![];
        for i in 0..self.op.get_attr_int("N")? as i32 {
            Outputs.push(crate::Output {
                operation: self.op.clone(),
                index: i,
            });
        }
        Ok(Outputs)
    }
    /// Returns the 'concat_dim' Input of this 'ConcatOffset' operation.
    pub fn concat_dim(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns a Vector of shape for 'shape' Input of this ConcatOffset operation.
    pub fn shape(&self) -> crate::Result<Vec<crate::Input>> {
        let mut Inputs = vec![];
        for i in 1..self.op.get_attr_int("N")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
}
impl From<ConcatOffsetInst> for crate::Operation {
    fn from(inst: ConcatOffsetInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ConcatOffset::new().build(concat_dim, shape, scope)`.
pub fn concat_offset<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    concat_dim: O0,
    shape: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ConcatOffset::new().build(concat_dim, shape, scope)
}

/// Builder for the `ConcatV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ConcatV2 {
    N: ::std::option::Option<i64>,
    T: ::std::option::Option<crate::DataType>,
    Tidx: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ConcatV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ConcatV2Inst {
    /// An instance of a fully built ConcatV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ConcatV2 {
    /// Creates a new `ConcatV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `N` attribute.
    pub fn N<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.N = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tidx` attribute.
    pub fn Tidx<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Tidx = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ConcatV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        values: O0,
        axis: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(values.into(), axis.into(), scope)
    }
    fn build_impl(
        &self,
        values: crate::Output,
        axis: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ConcatV2", |nd| {
            nd.add_input(values);
            nd.add_input(axis);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.N {
                nd.set_attr_int("N", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tidx {
                nd.set_attr_type("Tidx", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ConcatV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        values: Vec<crate::Output>,
        axis: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ConcatV2Inst> {
        let op = scope.new_operation("ConcatV2", |builder| {
            builder.add_input_list(&values);
            builder.add_input(axis);
            builder.set_attr_int("N", values.clone().len() as i64)?;
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tidx {
                builder.set_attr_type("Tidx", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ConcatV2Inst { op })
    }
}
impl ConcatV2Inst {
    /// Returns the 'output' Output of this 'ConcatV2' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns a Vector of values for 'values' Input of this ConcatV2 operation.
    pub fn values(&self) -> crate::Result<Vec<crate::Input>> {
        let mut Inputs = vec![];
        for i in 0..self.op.get_attr_int("N")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
    /// Returns the 'axis' Input of this 'ConcatV2' operation.
    pub fn axis(&self) -> crate::Result<crate::Input> {
        let dynamic_offset = (self.op.get_attr_int("N")? + 1) as i32;
        Ok(crate::Input {
            operation: &self.op,
            index: dynamic_offset,
        })
    }
}
impl From<ConcatV2Inst> for crate::Operation {
    fn from(inst: ConcatV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ConcatV2::new().build(values, axis, scope)`.
pub fn concat_v2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    values: O0,
    axis: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ConcatV2::new().build(values, axis, scope)
}

/// Builder for the `ConcatenateDataset` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ConcatenateDataset {
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    metadata: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ConcatenateDataset' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ConcatenateDatasetInst {
    /// An instance of a fully built ConcatenateDataset Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ConcatenateDataset {
    /// Creates a new `ConcatenateDataset`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `metadata` attribute.
    pub fn metadata<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.metadata = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ConcatenateDataset` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input_dataset: O0,
        another_dataset: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input_dataset.into(), another_dataset.into(), scope)
    }
    fn build_impl(
        &self,
        input_dataset: crate::Output,
        another_dataset: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ConcatenateDataset", |nd| {
            nd.add_input(input_dataset);
            nd.add_input(another_dataset);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.metadata {
                nd.set_attr_string("metadata", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ConcatenateDataset' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_dataset: crate::Output,
        another_dataset: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ConcatenateDatasetInst> {
        let op = scope.new_operation("ConcatenateDataset", |builder| {
            builder.add_input(input_dataset);
            builder.add_input(another_dataset);
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.metadata {
                builder.set_attr_string("metadata", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ConcatenateDatasetInst { op })
    }
}
impl ConcatenateDatasetInst {
    /// Returns the 'handle' Output of this 'ConcatenateDataset' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_dataset' Input of this 'ConcatenateDataset' operation.
    pub fn input_dataset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'another_dataset' Input of this 'ConcatenateDataset' operation.
    pub fn another_dataset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<ConcatenateDatasetInst> for crate::Operation {
    fn from(inst: ConcatenateDatasetInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ConcatenateDataset::new().build(input_dataset, another_dataset, scope)`.
pub fn concatenate_dataset<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    input_dataset: O0,
    another_dataset: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ConcatenateDataset::new().build(input_dataset, another_dataset, scope)
}

/// Builder for the `ConditionalAccumulator` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ConditionalAccumulator {
    dtype: ::std::option::Option<crate::DataType>,
    shape: ::std::option::Option<crate::Shape>,
    container: ::std::option::Option<::std::string::String>,
    shared_name: ::std::option::Option<::std::string::String>,
    reduction_type: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ConditionalAccumulator' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ConditionalAccumulatorInst {
    /// An instance of a fully built ConditionalAccumulator Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ConditionalAccumulator {
    /// Creates a new `ConditionalAccumulator`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `dtype` attribute.
    pub fn dtype<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shape` attribute.
    pub fn shape<ArgType: ::std::convert::Into<crate::Shape>>(mut self, value: ArgType) -> Self {
        self.shape = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `container` attribute.
    pub fn container<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.container = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shared_name` attribute.
    pub fn shared_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.shared_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `reduction_type` attribute.
    pub fn reduction_type<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.reduction_type = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ConditionalAccumulator` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("ConditionalAccumulator", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                nd.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shape {
                nd.set_attr_shape("shape", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.container {
                nd.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                nd.set_attr_string("shared_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.reduction_type {
                nd.set_attr_string("reduction_type", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ConditionalAccumulator' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        scope: &mut crate::Scope,
    ) -> crate::Result<ConditionalAccumulatorInst> {
        let op = scope.new_operation("ConditionalAccumulator", |builder| {
            if let ::std::option::Option::Some(value) = &self.dtype {
                builder.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shape {
                builder.set_attr_shape("shape", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.container {
                builder.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                builder.set_attr_string("shared_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.reduction_type {
                builder.set_attr_string("reduction_type", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ConditionalAccumulatorInst { op })
    }
}
impl ConditionalAccumulatorInst {
    /// Returns the 'handle' Output of this 'ConditionalAccumulator' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
}
impl From<ConditionalAccumulatorInst> for crate::Operation {
    fn from(inst: ConditionalAccumulatorInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ConditionalAccumulator::new().build(scope)`.
pub fn conditional_accumulator(scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
    ConditionalAccumulator::new().build(scope)
}

/// Builder for the `ConfigureAndInitializeGlobalTPU` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ConfigureAndInitializeGlobalTPU {
    use_tfrt_host_runtime: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ConfigureAndInitializeGlobalTPU' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ConfigureAndInitializeGlobalTPUInst {
    /// An instance of a fully built ConfigureAndInitializeGlobalTPU Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ConfigureAndInitializeGlobalTPU {
    /// Creates a new `ConfigureAndInitializeGlobalTPU`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `use_tfrt_host_runtime` attribute.
    pub fn use_tfrt_host_runtime<ArgType: ::std::convert::Into<bool>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.use_tfrt_host_runtime = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ConfigureAndInitializeGlobalTPU` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("ConfigureAndInitializeGlobalTPU", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.use_tfrt_host_runtime {
                nd.set_attr_bool("use_tfrt_host_runtime", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ConfigureAndInitializeGlobalTPU' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        scope: &mut crate::Scope,
    ) -> crate::Result<ConfigureAndInitializeGlobalTPUInst> {
        let op = scope.new_operation("ConfigureAndInitializeGlobalTPU", |builder| {
            if let ::std::option::Option::Some(value) = &self.use_tfrt_host_runtime {
                builder.set_attr_bool("use_tfrt_host_runtime", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ConfigureAndInitializeGlobalTPUInst { op })
    }
}
impl ConfigureAndInitializeGlobalTPUInst {
    /// Returns the 'output' Output of this 'ConfigureAndInitializeGlobalTPU' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
}
impl From<ConfigureAndInitializeGlobalTPUInst> for crate::Operation {
    fn from(inst: ConfigureAndInitializeGlobalTPUInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ConfigureAndInitializeGlobalTPU::new().build(scope)`.
pub fn configure_and_initialize_global_tpu(
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ConfigureAndInitializeGlobalTPU::new().build(scope)
}

/// Builder for the `ConfigureDistributedTPU` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ConfigureDistributedTPU {
    embedding_config: ::std::option::Option<::std::string::String>,
    tpu_embedding_config: ::std::option::Option<::std::string::String>,
    is_global_init: ::std::option::Option<bool>,
    enable_whole_mesh_compilations: ::std::option::Option<bool>,
    compilation_failure_closes_chips: ::std::option::Option<bool>,
    tpu_cancellation_closes_chips: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ConfigureDistributedTPU' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ConfigureDistributedTPUInst {
    /// An instance of a fully built ConfigureDistributedTPU Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ConfigureDistributedTPU {
    /// Creates a new `ConfigureDistributedTPU`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `embedding_config` attribute.
    pub fn embedding_config<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.embedding_config = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `tpu_embedding_config` attribute.
    pub fn tpu_embedding_config<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.tpu_embedding_config = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `is_global_init` attribute.
    pub fn is_global_init<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.is_global_init = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `enable_whole_mesh_compilations` attribute.
    pub fn enable_whole_mesh_compilations<ArgType: ::std::convert::Into<bool>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.enable_whole_mesh_compilations = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `compilation_failure_closes_chips` attribute.
    pub fn compilation_failure_closes_chips<ArgType: ::std::convert::Into<bool>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.compilation_failure_closes_chips = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `tpu_cancellation_closes_chips` attribute.
    pub fn tpu_cancellation_closes_chips<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.tpu_cancellation_closes_chips = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ConfigureDistributedTPU` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("ConfigureDistributedTPU", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.embedding_config {
                nd.set_attr_string("embedding_config", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.tpu_embedding_config {
                nd.set_attr_string("tpu_embedding_config", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.is_global_init {
                nd.set_attr_bool("is_global_init", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.enable_whole_mesh_compilations {
                nd.set_attr_bool("enable_whole_mesh_compilations", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.compilation_failure_closes_chips {
                nd.set_attr_bool("compilation_failure_closes_chips", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.tpu_cancellation_closes_chips {
                nd.set_attr_int("tpu_cancellation_closes_chips", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ConfigureDistributedTPU' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        scope: &mut crate::Scope,
    ) -> crate::Result<ConfigureDistributedTPUInst> {
        let op = scope.new_operation("ConfigureDistributedTPU", |builder| {
            if let ::std::option::Option::Some(value) = &self.embedding_config {
                builder.set_attr_string("embedding_config", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.tpu_embedding_config {
                builder.set_attr_string("tpu_embedding_config", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.is_global_init {
                builder.set_attr_bool("is_global_init", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.enable_whole_mesh_compilations {
                builder.set_attr_bool("enable_whole_mesh_compilations", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.compilation_failure_closes_chips {
                builder.set_attr_bool("compilation_failure_closes_chips", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.tpu_cancellation_closes_chips {
                builder.set_attr_int("tpu_cancellation_closes_chips", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ConfigureDistributedTPUInst { op })
    }
}
impl ConfigureDistributedTPUInst {
    /// Returns the 'topology' Output of this 'ConfigureDistributedTPU' operation.
    pub fn topology(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
}
impl From<ConfigureDistributedTPUInst> for crate::Operation {
    fn from(inst: ConfigureDistributedTPUInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ConfigureDistributedTPU::new().build(scope)`.
pub fn configure_distributed_tpu(scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
    ConfigureDistributedTPU::new().build(scope)
}

/// Builder for the `ConfigureTPUEmbedding` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ConfigureTPUEmbedding {
    config: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ConfigureTPUEmbedding' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ConfigureTPUEmbeddingInst {
    /// An instance of a fully built ConfigureTPUEmbedding Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ConfigureTPUEmbedding {
    /// Creates a new `ConfigureTPUEmbedding`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `config` attribute.
    pub fn config<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.config = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ConfigureTPUEmbedding` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("ConfigureTPUEmbedding", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.config {
                nd.set_attr_string("config", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ConfigureTPUEmbedding' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        scope: &mut crate::Scope,
    ) -> crate::Result<ConfigureTPUEmbeddingInst> {
        let op = scope.new_operation("ConfigureTPUEmbedding", |builder| {
            if let ::std::option::Option::Some(value) = &self.config {
                builder.set_attr_string("config", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ConfigureTPUEmbeddingInst { op })
    }
}
impl ConfigureTPUEmbeddingInst {}
impl From<ConfigureTPUEmbeddingInst> for crate::Operation {
    fn from(inst: ConfigureTPUEmbeddingInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ConfigureTPUEmbedding::new().build(scope)`.
pub fn configure_tpuembedding(scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
    ConfigureTPUEmbedding::new().build(scope)
}

/// Builder for the `ConfigureTPUEmbeddingHost` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ConfigureTPUEmbeddingHost {
    config: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ConfigureTPUEmbeddingHost' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ConfigureTPUEmbeddingHostInst {
    /// An instance of a fully built ConfigureTPUEmbeddingHost Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ConfigureTPUEmbeddingHost {
    /// Creates a new `ConfigureTPUEmbeddingHost`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `config` attribute.
    pub fn config<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.config = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ConfigureTPUEmbeddingHost` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        common_config: O0,
        memory_config: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(common_config.into(), memory_config.into(), scope)
    }
    fn build_impl(
        &self,
        common_config: crate::Output,
        memory_config: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ConfigureTPUEmbeddingHost", |nd| {
            nd.add_input(common_config);
            nd.add_input(memory_config);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.config {
                nd.set_attr_string("config", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ConfigureTPUEmbeddingHost' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        common_config: crate::Output,
        memory_config: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ConfigureTPUEmbeddingHostInst> {
        let op = scope.new_operation("ConfigureTPUEmbeddingHost", |builder| {
            builder.add_input(common_config);
            builder.add_input(memory_config);
            if let ::std::option::Option::Some(value) = &self.config {
                builder.set_attr_string("config", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ConfigureTPUEmbeddingHostInst { op })
    }
}
impl ConfigureTPUEmbeddingHostInst {
    /// Returns the 'network_config' Output of this 'ConfigureTPUEmbeddingHost' operation.
    pub fn network_config(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'common_config' Input of this 'ConfigureTPUEmbeddingHost' operation.
    pub fn common_config(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'memory_config' Input of this 'ConfigureTPUEmbeddingHost' operation.
    pub fn memory_config(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<ConfigureTPUEmbeddingHostInst> for crate::Operation {
    fn from(inst: ConfigureTPUEmbeddingHostInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ConfigureTPUEmbeddingHost::new().build(common_config, memory_config, scope)`.
pub fn configure_tpuembedding_host<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    common_config: O0,
    memory_config: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ConfigureTPUEmbeddingHost::new().build(common_config, memory_config, scope)
}

/// Builder for the `ConfigureTPUEmbeddingMemory` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ConfigureTPUEmbeddingMemory {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ConfigureTPUEmbeddingMemory' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ConfigureTPUEmbeddingMemoryInst {
    /// An instance of a fully built ConfigureTPUEmbeddingMemory Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ConfigureTPUEmbeddingMemory {
    /// Creates a new `ConfigureTPUEmbeddingMemory`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ConfigureTPUEmbeddingMemory` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        common_config: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(common_config.into(), scope)
    }
    fn build_impl(
        &self,
        common_config: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ConfigureTPUEmbeddingMemory", |nd| {
            nd.add_input(common_config);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ConfigureTPUEmbeddingMemory' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        common_config: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ConfigureTPUEmbeddingMemoryInst> {
        let op = scope.new_operation("ConfigureTPUEmbeddingMemory", |builder| {
            builder.add_input(common_config);
            ::std::result::Result::Ok(())
        })?;
        Ok(ConfigureTPUEmbeddingMemoryInst { op })
    }
}
impl ConfigureTPUEmbeddingMemoryInst {
    /// Returns the 'memory_config' Output of this 'ConfigureTPUEmbeddingMemory' operation.
    pub fn memory_config(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'common_config' Input of this 'ConfigureTPUEmbeddingMemory' operation.
    pub fn common_config(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<ConfigureTPUEmbeddingMemoryInst> for crate::Operation {
    fn from(inst: ConfigureTPUEmbeddingMemoryInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ConfigureTPUEmbeddingMemory::new().build(common_config, scope)`.
pub fn configure_tpuembedding_memory<O0: ::std::convert::Into<crate::Output>>(
    common_config: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ConfigureTPUEmbeddingMemory::new().build(common_config, scope)
}

/// Builder for the `Conj` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Conj {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Conj' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ConjInst {
    /// An instance of a fully built Conj Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Conj {
    /// Creates a new `Conj`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Conj` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Conj", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Conj' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ConjInst> {
        let op = scope.new_operation("Conj", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ConjInst { op })
    }
}
impl ConjInst {
    /// Returns the 'output' Output of this 'Conj' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'Conj' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<ConjInst> for crate::Operation {
    fn from(inst: ConjInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Conj::new().build(input, scope)`.
pub fn conj<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Conj::new().build(input, scope)
}

/// Builder for the `ConjugateTranspose` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ConjugateTranspose {
    T: ::std::option::Option<crate::DataType>,
    Tperm: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ConjugateTranspose' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ConjugateTransposeInst {
    /// An instance of a fully built ConjugateTranspose Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ConjugateTranspose {
    /// Creates a new `ConjugateTranspose`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tperm` attribute.
    pub fn Tperm<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Tperm = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ConjugateTranspose` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        x: O0,
        perm: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), perm.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        perm: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ConjugateTranspose", |nd| {
            nd.add_input(x);
            nd.add_input(perm);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tperm {
                nd.set_attr_type("Tperm", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ConjugateTranspose' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        perm: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ConjugateTransposeInst> {
        let op = scope.new_operation("ConjugateTranspose", |builder| {
            builder.add_input(x);
            builder.add_input(perm);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tperm {
                builder.set_attr_type("Tperm", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ConjugateTransposeInst { op })
    }
}
impl ConjugateTransposeInst {
    /// Returns the 'y' Output of this 'ConjugateTranspose' operation.
    pub fn y(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'ConjugateTranspose' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'perm' Input of this 'ConjugateTranspose' operation.
    pub fn perm(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<ConjugateTransposeInst> for crate::Operation {
    fn from(inst: ConjugateTransposeInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ConjugateTranspose::new().build(x, perm, scope)`.
pub fn conjugate_transpose<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    x: O0,
    perm: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ConjugateTranspose::new().build(x, perm, scope)
}

/// Builder for the `ConnectTPUEmbeddingHosts` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ConnectTPUEmbeddingHosts {
    N: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ConnectTPUEmbeddingHosts' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ConnectTPUEmbeddingHostsInst {
    /// An instance of a fully built ConnectTPUEmbeddingHosts Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ConnectTPUEmbeddingHosts {
    /// Creates a new `ConnectTPUEmbeddingHosts`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `N` attribute.
    pub fn N<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.N = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ConnectTPUEmbeddingHosts` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        network_configs: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(network_configs.into(), scope)
    }
    fn build_impl(
        &self,
        network_configs: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ConnectTPUEmbeddingHosts", |nd| {
            nd.add_input(network_configs);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.N {
                nd.set_attr_int("N", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ConnectTPUEmbeddingHosts' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        network_configs: Vec<crate::Output>,
        scope: &mut crate::Scope,
    ) -> crate::Result<ConnectTPUEmbeddingHostsInst> {
        let op = scope.new_operation("ConnectTPUEmbeddingHosts", |builder| {
            builder.add_input_list(&network_configs);
            builder.set_attr_int("N", network_configs.clone().len() as i64)?;
            ::std::result::Result::Ok(())
        })?;
        Ok(ConnectTPUEmbeddingHostsInst { op })
    }
}
impl ConnectTPUEmbeddingHostsInst {
    /// Returns a Vector of network_configs for 'network_configs' Input of this ConnectTPUEmbeddingHosts operation.
    pub fn network_configs(&self) -> crate::Result<Vec<crate::Input>> {
        let mut Inputs = vec![];
        for i in 0..self.op.get_attr_int("N")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
}
impl From<ConnectTPUEmbeddingHostsInst> for crate::Operation {
    fn from(inst: ConnectTPUEmbeddingHostsInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ConnectTPUEmbeddingHosts::new().build(network_configs, scope)`.
pub fn connect_tpuembedding_hosts<O0: ::std::convert::Into<crate::Output>>(
    network_configs: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ConnectTPUEmbeddingHosts::new().build(network_configs, scope)
}

/// Builder for the `Const` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Const {
    value: ::std::option::Option<::std::boxed::Box<dyn crate::AnyTensor>>,
    dtype: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Const' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ConstInst {
    /// An instance of a fully built Const Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Const {
    /// Creates a new `Const`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `value` attribute.
    pub fn value<T: crate::TensorType, ArgType: ::std::convert::Into<crate::Tensor<T>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.value = ::std::option::Option::Some(
            (::std::boxed::Box::new(value.into()) as ::std::boxed::Box<dyn crate::AnyTensor>),
        );
        self
    }

    /// Sets the `dtype` attribute.
    pub fn dtype<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Const` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("Const", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.value {
                nd.set_attr_any_tensor("value", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                nd.set_attr_type("dtype", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Const' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(&self, scope: &mut crate::Scope) -> crate::Result<ConstInst> {
        let op = scope.new_operation("Const", |builder| {
            if let ::std::option::Option::Some(value) = &self.value {
                builder.set_attr_any_tensor("value", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                builder.set_attr_type("dtype", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ConstInst { op })
    }
}
impl ConstInst {
    /// Returns the 'output' Output of this 'Const' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
}
impl From<ConstInst> for crate::Operation {
    fn from(inst: ConstInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Const::new().build(scope)`.
pub fn const_(scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
    Const::new().build(scope)
}

/// Builder for the `ConsumeMutexLock` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ConsumeMutexLock {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ConsumeMutexLock' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ConsumeMutexLockInst {
    /// An instance of a fully built ConsumeMutexLock Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ConsumeMutexLock {
    /// Creates a new `ConsumeMutexLock`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ConsumeMutexLock` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        mutex_lock: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(mutex_lock.into(), scope)
    }
    fn build_impl(
        &self,
        mutex_lock: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ConsumeMutexLock", |nd| {
            nd.add_input(mutex_lock);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ConsumeMutexLock' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        mutex_lock: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ConsumeMutexLockInst> {
        let op = scope.new_operation("ConsumeMutexLock", |builder| {
            builder.add_input(mutex_lock);
            ::std::result::Result::Ok(())
        })?;
        Ok(ConsumeMutexLockInst { op })
    }
}
impl ConsumeMutexLockInst {
    /// Returns the 'mutex_lock' Input of this 'ConsumeMutexLock' operation.
    pub fn mutex_lock(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<ConsumeMutexLockInst> for crate::Operation {
    fn from(inst: ConsumeMutexLockInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ConsumeMutexLock::new().build(mutex_lock, scope)`.
pub fn consume_mutex_lock<O0: ::std::convert::Into<crate::Output>>(
    mutex_lock: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ConsumeMutexLock::new().build(mutex_lock, scope)
}

/// Builder for the `ControlTrigger` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ControlTrigger {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ControlTrigger' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ControlTriggerInst {
    /// An instance of a fully built ControlTrigger Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ControlTrigger {
    /// Creates a new `ControlTrigger`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ControlTrigger` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("ControlTrigger", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ControlTrigger' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(&self, scope: &mut crate::Scope) -> crate::Result<ControlTriggerInst> {
        let op = scope.new_operation("ControlTrigger", |builder| ::std::result::Result::Ok(()))?;
        Ok(ControlTriggerInst { op })
    }
}
impl ControlTriggerInst {}
impl From<ControlTriggerInst> for crate::Operation {
    fn from(inst: ControlTriggerInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ControlTrigger::new().build(scope)`.
pub fn control_trigger(scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
    ControlTrigger::new().build(scope)
}

/// Builder for the `Conv2D` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Conv2D {
    T: ::std::option::Option<crate::DataType>,
    strides: ::std::option::Option<::std::vec::Vec<i64>>,
    use_cudnn_on_gpu: ::std::option::Option<bool>,
    padding: ::std::option::Option<::std::string::String>,
    explicit_paddings: ::std::option::Option<::std::vec::Vec<i64>>,
    data_format: ::std::option::Option<::std::string::String>,
    dilations: ::std::option::Option<::std::vec::Vec<i64>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Conv2D' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct Conv2DInst {
    /// An instance of a fully built Conv2D Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Conv2D {
    /// Creates a new `Conv2D`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `strides` attribute.
    pub fn strides<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.strides = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_cudnn_on_gpu` attribute.
    pub fn use_cudnn_on_gpu<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.use_cudnn_on_gpu = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `padding` attribute.
    pub fn padding<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.padding = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `explicit_paddings` attribute.
    pub fn explicit_paddings<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.explicit_paddings = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `data_format` attribute.
    pub fn data_format<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.data_format = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `dilations` attribute.
    pub fn dilations<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.dilations = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Conv2D` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        filter: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), filter.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        filter: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Conv2D", |nd| {
            nd.add_input(input);
            nd.add_input(filter);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.strides {
                nd.set_attr_int_list("strides", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_cudnn_on_gpu {
                nd.set_attr_bool("use_cudnn_on_gpu", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding {
                nd.set_attr_string("padding", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.explicit_paddings {
                nd.set_attr_int_list("explicit_paddings", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.data_format {
                nd.set_attr_string("data_format", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dilations {
                nd.set_attr_int_list("dilations", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Conv2D' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        filter: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<Conv2DInst> {
        let op = scope.new_operation("Conv2D", |builder| {
            builder.add_input(input);
            builder.add_input(filter);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.strides {
                builder.set_attr_int_list("strides", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_cudnn_on_gpu {
                builder.set_attr_bool("use_cudnn_on_gpu", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding {
                builder.set_attr_string("padding", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.explicit_paddings {
                builder.set_attr_int_list("explicit_paddings", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.data_format {
                builder.set_attr_string("data_format", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dilations {
                builder.set_attr_int_list("dilations", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(Conv2DInst { op })
    }
}
impl Conv2DInst {
    /// Returns the 'output' Output of this 'Conv2D' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'Conv2D' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'filter' Input of this 'Conv2D' operation.
    pub fn filter(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<Conv2DInst> for crate::Operation {
    fn from(inst: Conv2DInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Conv2D::new().build(input, filter, scope)`.
pub fn conv2_d<O0: ::std::convert::Into<crate::Output>, O1: ::std::convert::Into<crate::Output>>(
    input: O0,
    filter: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Conv2D::new().build(input, filter, scope)
}

/// Builder for the `Conv2DBackpropFilter` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Conv2DBackpropFilter {
    T: ::std::option::Option<crate::DataType>,
    strides: ::std::option::Option<::std::vec::Vec<i64>>,
    use_cudnn_on_gpu: ::std::option::Option<bool>,
    padding: ::std::option::Option<::std::string::String>,
    explicit_paddings: ::std::option::Option<::std::vec::Vec<i64>>,
    data_format: ::std::option::Option<::std::string::String>,
    dilations: ::std::option::Option<::std::vec::Vec<i64>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Conv2DBackpropFilter' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct Conv2DBackpropFilterInst {
    /// An instance of a fully built Conv2DBackpropFilter Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Conv2DBackpropFilter {
    /// Creates a new `Conv2DBackpropFilter`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `strides` attribute.
    pub fn strides<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.strides = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_cudnn_on_gpu` attribute.
    pub fn use_cudnn_on_gpu<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.use_cudnn_on_gpu = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `padding` attribute.
    pub fn padding<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.padding = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `explicit_paddings` attribute.
    pub fn explicit_paddings<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.explicit_paddings = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `data_format` attribute.
    pub fn data_format<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.data_format = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `dilations` attribute.
    pub fn dilations<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.dilations = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Conv2DBackpropFilter` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        filter_sizes: O1,
        out_backprop: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            input.into(),
            filter_sizes.into(),
            out_backprop.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        input: crate::Output,
        filter_sizes: crate::Output,
        out_backprop: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Conv2DBackpropFilter", |nd| {
            nd.add_input(input);
            nd.add_input(filter_sizes);
            nd.add_input(out_backprop);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.strides {
                nd.set_attr_int_list("strides", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_cudnn_on_gpu {
                nd.set_attr_bool("use_cudnn_on_gpu", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding {
                nd.set_attr_string("padding", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.explicit_paddings {
                nd.set_attr_int_list("explicit_paddings", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.data_format {
                nd.set_attr_string("data_format", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dilations {
                nd.set_attr_int_list("dilations", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Conv2DBackpropFilter' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        filter_sizes: crate::Output,
        out_backprop: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<Conv2DBackpropFilterInst> {
        let op = scope.new_operation("Conv2DBackpropFilter", |builder| {
            builder.add_input(input);
            builder.add_input(filter_sizes);
            builder.add_input(out_backprop);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.strides {
                builder.set_attr_int_list("strides", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_cudnn_on_gpu {
                builder.set_attr_bool("use_cudnn_on_gpu", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding {
                builder.set_attr_string("padding", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.explicit_paddings {
                builder.set_attr_int_list("explicit_paddings", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.data_format {
                builder.set_attr_string("data_format", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dilations {
                builder.set_attr_int_list("dilations", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(Conv2DBackpropFilterInst { op })
    }
}
impl Conv2DBackpropFilterInst {
    /// Returns the 'output' Output of this 'Conv2DBackpropFilter' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'Conv2DBackpropFilter' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'filter_sizes' Input of this 'Conv2DBackpropFilter' operation.
    pub fn filter_sizes(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'out_backprop' Input of this 'Conv2DBackpropFilter' operation.
    pub fn out_backprop(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<Conv2DBackpropFilterInst> for crate::Operation {
    fn from(inst: Conv2DBackpropFilterInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Conv2DBackpropFilter::new().build(input, filter_sizes, out_backprop, scope)`.
pub fn conv2_dbackprop_filter<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    input: O0,
    filter_sizes: O1,
    out_backprop: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Conv2DBackpropFilter::new().build(input, filter_sizes, out_backprop, scope)
}

/// Builder for the `Conv2DBackpropFilterV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Conv2DBackpropFilterV2 {
    T: ::std::option::Option<crate::DataType>,
    strides: ::std::option::Option<::std::vec::Vec<i64>>,
    use_cudnn_on_gpu: ::std::option::Option<bool>,
    padding: ::std::option::Option<::std::string::String>,
    explicit_paddings: ::std::option::Option<::std::vec::Vec<i64>>,
    data_format: ::std::option::Option<::std::string::String>,
    dilations: ::std::option::Option<::std::vec::Vec<i64>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Conv2DBackpropFilterV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct Conv2DBackpropFilterV2Inst {
    /// An instance of a fully built Conv2DBackpropFilterV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Conv2DBackpropFilterV2 {
    /// Creates a new `Conv2DBackpropFilterV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `strides` attribute.
    pub fn strides<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.strides = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_cudnn_on_gpu` attribute.
    pub fn use_cudnn_on_gpu<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.use_cudnn_on_gpu = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `padding` attribute.
    pub fn padding<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.padding = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `explicit_paddings` attribute.
    pub fn explicit_paddings<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.explicit_paddings = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `data_format` attribute.
    pub fn data_format<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.data_format = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `dilations` attribute.
    pub fn dilations<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.dilations = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Conv2DBackpropFilterV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        filter: O1,
        out_backprop: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), filter.into(), out_backprop.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        filter: crate::Output,
        out_backprop: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Conv2DBackpropFilterV2", |nd| {
            nd.add_input(input);
            nd.add_input(filter);
            nd.add_input(out_backprop);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.strides {
                nd.set_attr_int_list("strides", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_cudnn_on_gpu {
                nd.set_attr_bool("use_cudnn_on_gpu", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding {
                nd.set_attr_string("padding", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.explicit_paddings {
                nd.set_attr_int_list("explicit_paddings", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.data_format {
                nd.set_attr_string("data_format", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dilations {
                nd.set_attr_int_list("dilations", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Conv2DBackpropFilterV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        filter: crate::Output,
        out_backprop: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<Conv2DBackpropFilterV2Inst> {
        let op = scope.new_operation("Conv2DBackpropFilterV2", |builder| {
            builder.add_input(input);
            builder.add_input(filter);
            builder.add_input(out_backprop);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.strides {
                builder.set_attr_int_list("strides", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_cudnn_on_gpu {
                builder.set_attr_bool("use_cudnn_on_gpu", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding {
                builder.set_attr_string("padding", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.explicit_paddings {
                builder.set_attr_int_list("explicit_paddings", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.data_format {
                builder.set_attr_string("data_format", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dilations {
                builder.set_attr_int_list("dilations", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(Conv2DBackpropFilterV2Inst { op })
    }
}
impl Conv2DBackpropFilterV2Inst {
    /// Returns the 'output' Output of this 'Conv2DBackpropFilterV2' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'Conv2DBackpropFilterV2' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'filter' Input of this 'Conv2DBackpropFilterV2' operation.
    pub fn filter(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'out_backprop' Input of this 'Conv2DBackpropFilterV2' operation.
    pub fn out_backprop(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<Conv2DBackpropFilterV2Inst> for crate::Operation {
    fn from(inst: Conv2DBackpropFilterV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Conv2DBackpropFilterV2::new().build(input, filter, out_backprop, scope)`.
pub fn conv2_dbackprop_filter_v2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    input: O0,
    filter: O1,
    out_backprop: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Conv2DBackpropFilterV2::new().build(input, filter, out_backprop, scope)
}

/// Builder for the `Conv2DBackpropInput` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Conv2DBackpropInput {
    T: ::std::option::Option<crate::DataType>,
    strides: ::std::option::Option<::std::vec::Vec<i64>>,
    use_cudnn_on_gpu: ::std::option::Option<bool>,
    padding: ::std::option::Option<::std::string::String>,
    explicit_paddings: ::std::option::Option<::std::vec::Vec<i64>>,
    data_format: ::std::option::Option<::std::string::String>,
    dilations: ::std::option::Option<::std::vec::Vec<i64>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Conv2DBackpropInput' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct Conv2DBackpropInputInst {
    /// An instance of a fully built Conv2DBackpropInput Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Conv2DBackpropInput {
    /// Creates a new `Conv2DBackpropInput`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `strides` attribute.
    pub fn strides<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.strides = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_cudnn_on_gpu` attribute.
    pub fn use_cudnn_on_gpu<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.use_cudnn_on_gpu = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `padding` attribute.
    pub fn padding<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.padding = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `explicit_paddings` attribute.
    pub fn explicit_paddings<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.explicit_paddings = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `data_format` attribute.
    pub fn data_format<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.data_format = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `dilations` attribute.
    pub fn dilations<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.dilations = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Conv2DBackpropInput` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input_sizes: O0,
        filter: O1,
        out_backprop: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            input_sizes.into(),
            filter.into(),
            out_backprop.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        input_sizes: crate::Output,
        filter: crate::Output,
        out_backprop: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Conv2DBackpropInput", |nd| {
            nd.add_input(input_sizes);
            nd.add_input(filter);
            nd.add_input(out_backprop);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.strides {
                nd.set_attr_int_list("strides", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_cudnn_on_gpu {
                nd.set_attr_bool("use_cudnn_on_gpu", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding {
                nd.set_attr_string("padding", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.explicit_paddings {
                nd.set_attr_int_list("explicit_paddings", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.data_format {
                nd.set_attr_string("data_format", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dilations {
                nd.set_attr_int_list("dilations", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Conv2DBackpropInput' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_sizes: crate::Output,
        filter: crate::Output,
        out_backprop: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<Conv2DBackpropInputInst> {
        let op = scope.new_operation("Conv2DBackpropInput", |builder| {
            builder.add_input(input_sizes);
            builder.add_input(filter);
            builder.add_input(out_backprop);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.strides {
                builder.set_attr_int_list("strides", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_cudnn_on_gpu {
                builder.set_attr_bool("use_cudnn_on_gpu", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding {
                builder.set_attr_string("padding", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.explicit_paddings {
                builder.set_attr_int_list("explicit_paddings", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.data_format {
                builder.set_attr_string("data_format", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dilations {
                builder.set_attr_int_list("dilations", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(Conv2DBackpropInputInst { op })
    }
}
impl Conv2DBackpropInputInst {
    /// Returns the 'output' Output of this 'Conv2DBackpropInput' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_sizes' Input of this 'Conv2DBackpropInput' operation.
    pub fn input_sizes(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'filter' Input of this 'Conv2DBackpropInput' operation.
    pub fn filter(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'out_backprop' Input of this 'Conv2DBackpropInput' operation.
    pub fn out_backprop(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<Conv2DBackpropInputInst> for crate::Operation {
    fn from(inst: Conv2DBackpropInputInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Conv2DBackpropInput::new().build(input_sizes, filter, out_backprop, scope)`.
pub fn conv2_dbackprop_input<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    input_sizes: O0,
    filter: O1,
    out_backprop: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Conv2DBackpropInput::new().build(input_sizes, filter, out_backprop, scope)
}

/// Builder for the `Conv2DBackpropInputV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Conv2DBackpropInputV2 {
    T: ::std::option::Option<crate::DataType>,
    strides: ::std::option::Option<::std::vec::Vec<i64>>,
    use_cudnn_on_gpu: ::std::option::Option<bool>,
    padding: ::std::option::Option<::std::string::String>,
    explicit_paddings: ::std::option::Option<::std::vec::Vec<i64>>,
    data_format: ::std::option::Option<::std::string::String>,
    dilations: ::std::option::Option<::std::vec::Vec<i64>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Conv2DBackpropInputV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct Conv2DBackpropInputV2Inst {
    /// An instance of a fully built Conv2DBackpropInputV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Conv2DBackpropInputV2 {
    /// Creates a new `Conv2DBackpropInputV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `strides` attribute.
    pub fn strides<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.strides = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_cudnn_on_gpu` attribute.
    pub fn use_cudnn_on_gpu<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.use_cudnn_on_gpu = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `padding` attribute.
    pub fn padding<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.padding = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `explicit_paddings` attribute.
    pub fn explicit_paddings<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.explicit_paddings = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `data_format` attribute.
    pub fn data_format<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.data_format = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `dilations` attribute.
    pub fn dilations<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.dilations = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Conv2DBackpropInputV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        filter: O1,
        out_backprop: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), filter.into(), out_backprop.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        filter: crate::Output,
        out_backprop: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Conv2DBackpropInputV2", |nd| {
            nd.add_input(input);
            nd.add_input(filter);
            nd.add_input(out_backprop);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.strides {
                nd.set_attr_int_list("strides", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_cudnn_on_gpu {
                nd.set_attr_bool("use_cudnn_on_gpu", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding {
                nd.set_attr_string("padding", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.explicit_paddings {
                nd.set_attr_int_list("explicit_paddings", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.data_format {
                nd.set_attr_string("data_format", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dilations {
                nd.set_attr_int_list("dilations", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Conv2DBackpropInputV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        filter: crate::Output,
        out_backprop: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<Conv2DBackpropInputV2Inst> {
        let op = scope.new_operation("Conv2DBackpropInputV2", |builder| {
            builder.add_input(input);
            builder.add_input(filter);
            builder.add_input(out_backprop);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.strides {
                builder.set_attr_int_list("strides", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_cudnn_on_gpu {
                builder.set_attr_bool("use_cudnn_on_gpu", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding {
                builder.set_attr_string("padding", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.explicit_paddings {
                builder.set_attr_int_list("explicit_paddings", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.data_format {
                builder.set_attr_string("data_format", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dilations {
                builder.set_attr_int_list("dilations", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(Conv2DBackpropInputV2Inst { op })
    }
}
impl Conv2DBackpropInputV2Inst {
    /// Returns the 'output' Output of this 'Conv2DBackpropInputV2' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'Conv2DBackpropInputV2' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'filter' Input of this 'Conv2DBackpropInputV2' operation.
    pub fn filter(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'out_backprop' Input of this 'Conv2DBackpropInputV2' operation.
    pub fn out_backprop(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<Conv2DBackpropInputV2Inst> for crate::Operation {
    fn from(inst: Conv2DBackpropInputV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Conv2DBackpropInputV2::new().build(input, filter, out_backprop, scope)`.
pub fn conv2_dbackprop_input_v2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    input: O0,
    filter: O1,
    out_backprop: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Conv2DBackpropInputV2::new().build(input, filter, out_backprop, scope)
}

/// Builder for the `Conv3D` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Conv3D {
    T: ::std::option::Option<crate::DataType>,
    strides: ::std::option::Option<::std::vec::Vec<i64>>,
    padding: ::std::option::Option<::std::string::String>,
    data_format: ::std::option::Option<::std::string::String>,
    dilations: ::std::option::Option<::std::vec::Vec<i64>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Conv3D' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct Conv3DInst {
    /// An instance of a fully built Conv3D Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Conv3D {
    /// Creates a new `Conv3D`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `strides` attribute.
    pub fn strides<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.strides = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `padding` attribute.
    pub fn padding<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.padding = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `data_format` attribute.
    pub fn data_format<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.data_format = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `dilations` attribute.
    pub fn dilations<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.dilations = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Conv3D` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        filter: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), filter.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        filter: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Conv3D", |nd| {
            nd.add_input(input);
            nd.add_input(filter);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.strides {
                nd.set_attr_int_list("strides", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding {
                nd.set_attr_string("padding", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.data_format {
                nd.set_attr_string("data_format", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dilations {
                nd.set_attr_int_list("dilations", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Conv3D' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        filter: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<Conv3DInst> {
        let op = scope.new_operation("Conv3D", |builder| {
            builder.add_input(input);
            builder.add_input(filter);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.strides {
                builder.set_attr_int_list("strides", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding {
                builder.set_attr_string("padding", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.data_format {
                builder.set_attr_string("data_format", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dilations {
                builder.set_attr_int_list("dilations", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(Conv3DInst { op })
    }
}
impl Conv3DInst {
    /// Returns the 'output' Output of this 'Conv3D' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'Conv3D' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'filter' Input of this 'Conv3D' operation.
    pub fn filter(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<Conv3DInst> for crate::Operation {
    fn from(inst: Conv3DInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Conv3D::new().build(input, filter, scope)`.
pub fn conv3_d<O0: ::std::convert::Into<crate::Output>, O1: ::std::convert::Into<crate::Output>>(
    input: O0,
    filter: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Conv3D::new().build(input, filter, scope)
}

/// Builder for the `Conv3DBackpropFilter` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Conv3DBackpropFilter {
    T: ::std::option::Option<crate::DataType>,
    strides: ::std::option::Option<::std::vec::Vec<i64>>,
    padding: ::std::option::Option<::std::string::String>,
    dilations: ::std::option::Option<::std::vec::Vec<i64>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Conv3DBackpropFilter' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct Conv3DBackpropFilterInst {
    /// An instance of a fully built Conv3DBackpropFilter Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Conv3DBackpropFilter {
    /// Creates a new `Conv3DBackpropFilter`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `strides` attribute.
    pub fn strides<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.strides = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `padding` attribute.
    pub fn padding<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.padding = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `dilations` attribute.
    pub fn dilations<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.dilations = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Conv3DBackpropFilter` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        filter: O1,
        out_backprop: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), filter.into(), out_backprop.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        filter: crate::Output,
        out_backprop: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Conv3DBackpropFilter", |nd| {
            nd.add_input(input);
            nd.add_input(filter);
            nd.add_input(out_backprop);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.strides {
                nd.set_attr_int_list("strides", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding {
                nd.set_attr_string("padding", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dilations {
                nd.set_attr_int_list("dilations", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Conv3DBackpropFilter' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        filter: crate::Output,
        out_backprop: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<Conv3DBackpropFilterInst> {
        let op = scope.new_operation("Conv3DBackpropFilter", |builder| {
            builder.add_input(input);
            builder.add_input(filter);
            builder.add_input(out_backprop);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.strides {
                builder.set_attr_int_list("strides", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding {
                builder.set_attr_string("padding", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dilations {
                builder.set_attr_int_list("dilations", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(Conv3DBackpropFilterInst { op })
    }
}
impl Conv3DBackpropFilterInst {
    /// Returns the 'output' Output of this 'Conv3DBackpropFilter' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'Conv3DBackpropFilter' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'filter' Input of this 'Conv3DBackpropFilter' operation.
    pub fn filter(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'out_backprop' Input of this 'Conv3DBackpropFilter' operation.
    pub fn out_backprop(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<Conv3DBackpropFilterInst> for crate::Operation {
    fn from(inst: Conv3DBackpropFilterInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Conv3DBackpropFilter::new().build(input, filter, out_backprop, scope)`.
pub fn conv3_dbackprop_filter<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    input: O0,
    filter: O1,
    out_backprop: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Conv3DBackpropFilter::new().build(input, filter, out_backprop, scope)
}

/// Builder for the `Conv3DBackpropFilterV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Conv3DBackpropFilterV2 {
    T: ::std::option::Option<crate::DataType>,
    strides: ::std::option::Option<::std::vec::Vec<i64>>,
    padding: ::std::option::Option<::std::string::String>,
    data_format: ::std::option::Option<::std::string::String>,
    dilations: ::std::option::Option<::std::vec::Vec<i64>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Conv3DBackpropFilterV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct Conv3DBackpropFilterV2Inst {
    /// An instance of a fully built Conv3DBackpropFilterV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Conv3DBackpropFilterV2 {
    /// Creates a new `Conv3DBackpropFilterV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `strides` attribute.
    pub fn strides<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.strides = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `padding` attribute.
    pub fn padding<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.padding = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `data_format` attribute.
    pub fn data_format<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.data_format = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `dilations` attribute.
    pub fn dilations<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.dilations = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Conv3DBackpropFilterV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        filter_sizes: O1,
        out_backprop: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            input.into(),
            filter_sizes.into(),
            out_backprop.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        input: crate::Output,
        filter_sizes: crate::Output,
        out_backprop: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Conv3DBackpropFilterV2", |nd| {
            nd.add_input(input);
            nd.add_input(filter_sizes);
            nd.add_input(out_backprop);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.strides {
                nd.set_attr_int_list("strides", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding {
                nd.set_attr_string("padding", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.data_format {
                nd.set_attr_string("data_format", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dilations {
                nd.set_attr_int_list("dilations", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Conv3DBackpropFilterV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        filter_sizes: crate::Output,
        out_backprop: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<Conv3DBackpropFilterV2Inst> {
        let op = scope.new_operation("Conv3DBackpropFilterV2", |builder| {
            builder.add_input(input);
            builder.add_input(filter_sizes);
            builder.add_input(out_backprop);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.strides {
                builder.set_attr_int_list("strides", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding {
                builder.set_attr_string("padding", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.data_format {
                builder.set_attr_string("data_format", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dilations {
                builder.set_attr_int_list("dilations", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(Conv3DBackpropFilterV2Inst { op })
    }
}
impl Conv3DBackpropFilterV2Inst {
    /// Returns the 'output' Output of this 'Conv3DBackpropFilterV2' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'Conv3DBackpropFilterV2' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'filter_sizes' Input of this 'Conv3DBackpropFilterV2' operation.
    pub fn filter_sizes(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'out_backprop' Input of this 'Conv3DBackpropFilterV2' operation.
    pub fn out_backprop(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<Conv3DBackpropFilterV2Inst> for crate::Operation {
    fn from(inst: Conv3DBackpropFilterV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Conv3DBackpropFilterV2::new().build(input, filter_sizes, out_backprop, scope)`.
pub fn conv3_dbackprop_filter_v2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    input: O0,
    filter_sizes: O1,
    out_backprop: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Conv3DBackpropFilterV2::new().build(input, filter_sizes, out_backprop, scope)
}

/// Builder for the `Conv3DBackpropInput` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Conv3DBackpropInput {
    T: ::std::option::Option<crate::DataType>,
    strides: ::std::option::Option<::std::vec::Vec<i64>>,
    padding: ::std::option::Option<::std::string::String>,
    dilations: ::std::option::Option<::std::vec::Vec<i64>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Conv3DBackpropInput' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct Conv3DBackpropInputInst {
    /// An instance of a fully built Conv3DBackpropInput Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Conv3DBackpropInput {
    /// Creates a new `Conv3DBackpropInput`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `strides` attribute.
    pub fn strides<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.strides = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `padding` attribute.
    pub fn padding<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.padding = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `dilations` attribute.
    pub fn dilations<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.dilations = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Conv3DBackpropInput` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        filter: O1,
        out_backprop: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), filter.into(), out_backprop.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        filter: crate::Output,
        out_backprop: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Conv3DBackpropInput", |nd| {
            nd.add_input(input);
            nd.add_input(filter);
            nd.add_input(out_backprop);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.strides {
                nd.set_attr_int_list("strides", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding {
                nd.set_attr_string("padding", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dilations {
                nd.set_attr_int_list("dilations", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Conv3DBackpropInput' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        filter: crate::Output,
        out_backprop: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<Conv3DBackpropInputInst> {
        let op = scope.new_operation("Conv3DBackpropInput", |builder| {
            builder.add_input(input);
            builder.add_input(filter);
            builder.add_input(out_backprop);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.strides {
                builder.set_attr_int_list("strides", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding {
                builder.set_attr_string("padding", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dilations {
                builder.set_attr_int_list("dilations", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(Conv3DBackpropInputInst { op })
    }
}
impl Conv3DBackpropInputInst {
    /// Returns the 'output' Output of this 'Conv3DBackpropInput' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'Conv3DBackpropInput' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'filter' Input of this 'Conv3DBackpropInput' operation.
    pub fn filter(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'out_backprop' Input of this 'Conv3DBackpropInput' operation.
    pub fn out_backprop(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<Conv3DBackpropInputInst> for crate::Operation {
    fn from(inst: Conv3DBackpropInputInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Conv3DBackpropInput::new().build(input, filter, out_backprop, scope)`.
pub fn conv3_dbackprop_input<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    input: O0,
    filter: O1,
    out_backprop: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Conv3DBackpropInput::new().build(input, filter, out_backprop, scope)
}

/// Builder for the `Conv3DBackpropInputV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Conv3DBackpropInputV2 {
    T: ::std::option::Option<crate::DataType>,
    strides: ::std::option::Option<::std::vec::Vec<i64>>,
    padding: ::std::option::Option<::std::string::String>,
    data_format: ::std::option::Option<::std::string::String>,
    dilations: ::std::option::Option<::std::vec::Vec<i64>>,
    Tshape: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Conv3DBackpropInputV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct Conv3DBackpropInputV2Inst {
    /// An instance of a fully built Conv3DBackpropInputV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Conv3DBackpropInputV2 {
    /// Creates a new `Conv3DBackpropInputV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `strides` attribute.
    pub fn strides<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.strides = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `padding` attribute.
    pub fn padding<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.padding = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `data_format` attribute.
    pub fn data_format<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.data_format = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `dilations` attribute.
    pub fn dilations<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.dilations = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tshape` attribute.
    pub fn Tshape<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tshape = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Conv3DBackpropInputV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input_sizes: O0,
        filter: O1,
        out_backprop: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            input_sizes.into(),
            filter.into(),
            out_backprop.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        input_sizes: crate::Output,
        filter: crate::Output,
        out_backprop: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Conv3DBackpropInputV2", |nd| {
            nd.add_input(input_sizes);
            nd.add_input(filter);
            nd.add_input(out_backprop);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.strides {
                nd.set_attr_int_list("strides", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding {
                nd.set_attr_string("padding", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.data_format {
                nd.set_attr_string("data_format", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dilations {
                nd.set_attr_int_list("dilations", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tshape {
                nd.set_attr_type("Tshape", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Conv3DBackpropInputV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_sizes: crate::Output,
        filter: crate::Output,
        out_backprop: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<Conv3DBackpropInputV2Inst> {
        let op = scope.new_operation("Conv3DBackpropInputV2", |builder| {
            builder.add_input(input_sizes);
            builder.add_input(filter);
            builder.add_input(out_backprop);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.strides {
                builder.set_attr_int_list("strides", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding {
                builder.set_attr_string("padding", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.data_format {
                builder.set_attr_string("data_format", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dilations {
                builder.set_attr_int_list("dilations", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tshape {
                builder.set_attr_type("Tshape", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(Conv3DBackpropInputV2Inst { op })
    }
}
impl Conv3DBackpropInputV2Inst {
    /// Returns the 'output' Output of this 'Conv3DBackpropInputV2' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_sizes' Input of this 'Conv3DBackpropInputV2' operation.
    pub fn input_sizes(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'filter' Input of this 'Conv3DBackpropInputV2' operation.
    pub fn filter(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'out_backprop' Input of this 'Conv3DBackpropInputV2' operation.
    pub fn out_backprop(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<Conv3DBackpropInputV2Inst> for crate::Operation {
    fn from(inst: Conv3DBackpropInputV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Conv3DBackpropInputV2::new().build(input_sizes, filter, out_backprop, scope)`.
pub fn conv3_dbackprop_input_v2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    input_sizes: O0,
    filter: O1,
    out_backprop: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Conv3DBackpropInputV2::new().build(input_sizes, filter, out_backprop, scope)
}

/// Builder for the `Copy` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Copy {
    T: ::std::option::Option<crate::DataType>,
    tensor_name: ::std::option::Option<::std::string::String>,
    debug_ops_spec: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Copy' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct CopyInst {
    /// An instance of a fully built Copy Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Copy {
    /// Creates a new `Copy`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `tensor_name` attribute.
    pub fn tensor_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.tensor_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `debug_ops_spec` attribute.
    pub fn debug_ops_spec<ArgType: ::std::convert::Into<::std::vec::Vec<::std::string::String>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.debug_ops_spec = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Copy` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Copy", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.tensor_name {
                nd.set_attr_string("tensor_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.debug_ops_spec {
                nd.set_attr_string_list("debug_ops_spec", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Copy' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<CopyInst> {
        let op = scope.new_operation("Copy", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.tensor_name {
                builder.set_attr_string("tensor_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.debug_ops_spec {
                builder.set_attr_string_list("debug_ops_spec", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(CopyInst { op })
    }
}
impl CopyInst {
    /// Returns the 'output' Output of this 'Copy' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'Copy' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<CopyInst> for crate::Operation {
    fn from(inst: CopyInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Copy::new().build(input, scope)`.
pub fn copy<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Copy::new().build(input, scope)
}

/// Builder for the `CopyHost` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct CopyHost {
    T: ::std::option::Option<crate::DataType>,
    tensor_name: ::std::option::Option<::std::string::String>,
    debug_ops_spec: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'CopyHost' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct CopyHostInst {
    /// An instance of a fully built CopyHost Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl CopyHost {
    /// Creates a new `CopyHost`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `tensor_name` attribute.
    pub fn tensor_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.tensor_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `debug_ops_spec` attribute.
    pub fn debug_ops_spec<ArgType: ::std::convert::Into<::std::vec::Vec<::std::string::String>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.debug_ops_spec = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `CopyHost` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("CopyHost", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.tensor_name {
                nd.set_attr_string("tensor_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.debug_ops_spec {
                nd.set_attr_string_list("debug_ops_spec", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'CopyHost' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<CopyHostInst> {
        let op = scope.new_operation("CopyHost", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.tensor_name {
                builder.set_attr_string("tensor_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.debug_ops_spec {
                builder.set_attr_string_list("debug_ops_spec", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(CopyHostInst { op })
    }
}
impl CopyHostInst {
    /// Returns the 'output' Output of this 'CopyHost' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'CopyHost' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<CopyHostInst> for crate::Operation {
    fn from(inst: CopyHostInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `CopyHost::new().build(input, scope)`.
pub fn copy_host<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    CopyHost::new().build(input, scope)
}

/// Builder for the `CopyToMesh` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct CopyToMesh {
    layout: ::std::option::Option<::std::string::String>,
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'CopyToMesh' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct CopyToMeshInst {
    /// An instance of a fully built CopyToMesh Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl CopyToMesh {
    /// Creates a new `CopyToMesh`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `layout` attribute.
    pub fn layout<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.layout = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `CopyToMesh` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("CopyToMesh", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.layout {
                nd.set_attr_string("layout", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'CopyToMesh' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<CopyToMeshInst> {
        let op = scope.new_operation("CopyToMesh", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.layout {
                builder.set_attr_string("layout", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(CopyToMeshInst { op })
    }
}
impl CopyToMeshInst {
    /// Returns the 'output' Output of this 'CopyToMesh' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'CopyToMesh' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<CopyToMeshInst> for crate::Operation {
    fn from(inst: CopyToMeshInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `CopyToMesh::new().build(input, scope)`.
pub fn copy_to_mesh<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    CopyToMesh::new().build(input, scope)
}

/// Builder for the `CopyToMeshGrad` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct CopyToMeshGrad {
    reference_layout: ::std::option::Option<::std::string::String>,
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'CopyToMeshGrad' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct CopyToMeshGradInst {
    /// An instance of a fully built CopyToMeshGrad Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl CopyToMeshGrad {
    /// Creates a new `CopyToMeshGrad`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `reference_layout` attribute.
    pub fn reference_layout<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.reference_layout = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `CopyToMeshGrad` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        forward_input: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), forward_input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        forward_input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("CopyToMeshGrad", |nd| {
            nd.add_input(input);
            nd.add_input(forward_input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.reference_layout {
                nd.set_attr_string("reference_layout", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'CopyToMeshGrad' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        forward_input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<CopyToMeshGradInst> {
        let op = scope.new_operation("CopyToMeshGrad", |builder| {
            builder.add_input(input);
            builder.add_input(forward_input);
            if let ::std::option::Option::Some(value) = &self.reference_layout {
                builder.set_attr_string("reference_layout", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(CopyToMeshGradInst { op })
    }
}
impl CopyToMeshGradInst {
    /// Returns the 'output' Output of this 'CopyToMeshGrad' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'CopyToMeshGrad' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'forward_input' Input of this 'CopyToMeshGrad' operation.
    pub fn forward_input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<CopyToMeshGradInst> for crate::Operation {
    fn from(inst: CopyToMeshGradInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `CopyToMeshGrad::new().build(input, forward_input, scope)`.
pub fn copy_to_mesh_grad<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    input: O0,
    forward_input: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    CopyToMeshGrad::new().build(input, forward_input, scope)
}

/// Builder for the `Cos` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Cos {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Cos' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct CosInst {
    /// An instance of a fully built Cos Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Cos {
    /// Creates a new `Cos`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Cos` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        x: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Cos", |nd| {
            nd.add_input(x);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Cos' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<CosInst> {
        let op = scope.new_operation("Cos", |builder| {
            builder.add_input(x);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(CosInst { op })
    }
}
impl CosInst {
    /// Returns the 'y' Output of this 'Cos' operation.
    pub fn y(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'Cos' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<CosInst> for crate::Operation {
    fn from(inst: CosInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Cos::new().build(x, scope)`.
pub fn cos<O0: ::std::convert::Into<crate::Output>>(
    x: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Cos::new().build(x, scope)
}

/// Builder for the `Cosh` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Cosh {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Cosh' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct CoshInst {
    /// An instance of a fully built Cosh Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Cosh {
    /// Creates a new `Cosh`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Cosh` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        x: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Cosh", |nd| {
            nd.add_input(x);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Cosh' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<CoshInst> {
        let op = scope.new_operation("Cosh", |builder| {
            builder.add_input(x);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(CoshInst { op })
    }
}
impl CoshInst {
    /// Returns the 'y' Output of this 'Cosh' operation.
    pub fn y(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'Cosh' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<CoshInst> for crate::Operation {
    fn from(inst: CoshInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Cosh::new().build(x, scope)`.
pub fn cosh<O0: ::std::convert::Into<crate::Output>>(
    x: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Cosh::new().build(x, scope)
}

/// Builder for the `CountUpTo` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct CountUpTo {
    limit: ::std::option::Option<i64>,
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'CountUpTo' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct CountUpToInst {
    /// An instance of a fully built CountUpTo Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl CountUpTo {
    /// Creates a new `CountUpTo`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `limit` attribute.
    pub fn limit<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.limit = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `CountUpTo` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        ref_: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(ref_.into(), scope)
    }
    fn build_impl(
        &self,
        ref_: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("CountUpTo", |nd| {
            nd.add_input(ref_);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.limit {
                nd.set_attr_int("limit", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'CountUpTo' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        ref_: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<CountUpToInst> {
        let op = scope.new_operation("CountUpTo", |builder| {
            builder.add_input(ref_);
            if let ::std::option::Option::Some(value) = &self.limit {
                builder.set_attr_int("limit", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(CountUpToInst { op })
    }
}
impl CountUpToInst {
    /// Returns the 'output' Output of this 'CountUpTo' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'ref_' Input of this 'CountUpTo' operation.
    pub fn ref_(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<CountUpToInst> for crate::Operation {
    fn from(inst: CountUpToInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `CountUpTo::new().build(ref_, scope)`.
pub fn count_up_to<O0: ::std::convert::Into<crate::Output>>(
    ref_: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    CountUpTo::new().build(ref_, scope)
}

/// Builder for the `CreateSummaryDbWriter` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct CreateSummaryDbWriter {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'CreateSummaryDbWriter' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct CreateSummaryDbWriterInst {
    /// An instance of a fully built CreateSummaryDbWriter Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl CreateSummaryDbWriter {
    /// Creates a new `CreateSummaryDbWriter`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `CreateSummaryDbWriter` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
    >(
        &self,
        writer: O0,
        db_uri: O1,
        experiment_name: O2,
        run_name: O3,
        user_name: O4,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            writer.into(),
            db_uri.into(),
            experiment_name.into(),
            run_name.into(),
            user_name.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        writer: crate::Output,
        db_uri: crate::Output,
        experiment_name: crate::Output,
        run_name: crate::Output,
        user_name: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("CreateSummaryDbWriter", |nd| {
            nd.add_input(writer);
            nd.add_input(db_uri);
            nd.add_input(experiment_name);
            nd.add_input(run_name);
            nd.add_input(user_name);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'CreateSummaryDbWriter' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        writer: crate::Output,
        db_uri: crate::Output,
        experiment_name: crate::Output,
        run_name: crate::Output,
        user_name: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<CreateSummaryDbWriterInst> {
        let op = scope.new_operation("CreateSummaryDbWriter", |builder| {
            builder.add_input(writer);
            builder.add_input(db_uri);
            builder.add_input(experiment_name);
            builder.add_input(run_name);
            builder.add_input(user_name);
            ::std::result::Result::Ok(())
        })?;
        Ok(CreateSummaryDbWriterInst { op })
    }
}
impl CreateSummaryDbWriterInst {
    /// Returns the 'writer' Input of this 'CreateSummaryDbWriter' operation.
    pub fn writer(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'db_uri' Input of this 'CreateSummaryDbWriter' operation.
    pub fn db_uri(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'experiment_name' Input of this 'CreateSummaryDbWriter' operation.
    pub fn experiment_name(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'run_name' Input of this 'CreateSummaryDbWriter' operation.
    pub fn run_name(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'user_name' Input of this 'CreateSummaryDbWriter' operation.
    pub fn user_name(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
}
impl From<CreateSummaryDbWriterInst> for crate::Operation {
    fn from(inst: CreateSummaryDbWriterInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `CreateSummaryDbWriter::new().build(writer, db_uri, experiment_name, run_name, user_name, scope)`.
pub fn create_summary_db_writer<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
>(
    writer: O0,
    db_uri: O1,
    experiment_name: O2,
    run_name: O3,
    user_name: O4,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    CreateSummaryDbWriter::new().build(writer, db_uri, experiment_name, run_name, user_name, scope)
}

/// Builder for the `CreateSummaryFileWriter` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct CreateSummaryFileWriter {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'CreateSummaryFileWriter' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct CreateSummaryFileWriterInst {
    /// An instance of a fully built CreateSummaryFileWriter Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl CreateSummaryFileWriter {
    /// Creates a new `CreateSummaryFileWriter`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `CreateSummaryFileWriter` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
    >(
        &self,
        writer: O0,
        logdir: O1,
        max_queue: O2,
        flush_millis: O3,
        filename_suffix: O4,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            writer.into(),
            logdir.into(),
            max_queue.into(),
            flush_millis.into(),
            filename_suffix.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        writer: crate::Output,
        logdir: crate::Output,
        max_queue: crate::Output,
        flush_millis: crate::Output,
        filename_suffix: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("CreateSummaryFileWriter", |nd| {
            nd.add_input(writer);
            nd.add_input(logdir);
            nd.add_input(max_queue);
            nd.add_input(flush_millis);
            nd.add_input(filename_suffix);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'CreateSummaryFileWriter' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        writer: crate::Output,
        logdir: crate::Output,
        max_queue: crate::Output,
        flush_millis: crate::Output,
        filename_suffix: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<CreateSummaryFileWriterInst> {
        let op = scope.new_operation("CreateSummaryFileWriter", |builder| {
            builder.add_input(writer);
            builder.add_input(logdir);
            builder.add_input(max_queue);
            builder.add_input(flush_millis);
            builder.add_input(filename_suffix);
            ::std::result::Result::Ok(())
        })?;
        Ok(CreateSummaryFileWriterInst { op })
    }
}
impl CreateSummaryFileWriterInst {
    /// Returns the 'writer' Input of this 'CreateSummaryFileWriter' operation.
    pub fn writer(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'logdir' Input of this 'CreateSummaryFileWriter' operation.
    pub fn logdir(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'max_queue' Input of this 'CreateSummaryFileWriter' operation.
    pub fn max_queue(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'flush_millis' Input of this 'CreateSummaryFileWriter' operation.
    pub fn flush_millis(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'filename_suffix' Input of this 'CreateSummaryFileWriter' operation.
    pub fn filename_suffix(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
}
impl From<CreateSummaryFileWriterInst> for crate::Operation {
    fn from(inst: CreateSummaryFileWriterInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `CreateSummaryFileWriter::new().build(writer, logdir, max_queue, flush_millis, filename_suffix, scope)`.
pub fn create_summary_file_writer<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
>(
    writer: O0,
    logdir: O1,
    max_queue: O2,
    flush_millis: O3,
    filename_suffix: O4,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    CreateSummaryFileWriter::new().build(
        writer,
        logdir,
        max_queue,
        flush_millis,
        filename_suffix,
        scope,
    )
}

/// Builder for the `CropAndResize` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct CropAndResize {
    T: ::std::option::Option<crate::DataType>,
    method: ::std::option::Option<::std::string::String>,
    extrapolation_value: ::std::option::Option<f32>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'CropAndResize' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct CropAndResizeInst {
    /// An instance of a fully built CropAndResize Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl CropAndResize {
    /// Creates a new `CropAndResize`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `method` attribute.
    pub fn method<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.method = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `extrapolation_value` attribute.
    pub fn extrapolation_value<ArgType: ::std::convert::Into<f32>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.extrapolation_value = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `CropAndResize` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
    >(
        &self,
        image: O0,
        boxes: O1,
        box_ind: O2,
        crop_size: O3,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            image.into(),
            boxes.into(),
            box_ind.into(),
            crop_size.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        image: crate::Output,
        boxes: crate::Output,
        box_ind: crate::Output,
        crop_size: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("CropAndResize", |nd| {
            nd.add_input(image);
            nd.add_input(boxes);
            nd.add_input(box_ind);
            nd.add_input(crop_size);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.method {
                nd.set_attr_string("method", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.extrapolation_value {
                nd.set_attr_float("extrapolation_value", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'CropAndResize' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        image: crate::Output,
        boxes: crate::Output,
        box_ind: crate::Output,
        crop_size: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<CropAndResizeInst> {
        let op = scope.new_operation("CropAndResize", |builder| {
            builder.add_input(image);
            builder.add_input(boxes);
            builder.add_input(box_ind);
            builder.add_input(crop_size);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.method {
                builder.set_attr_string("method", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.extrapolation_value {
                builder.set_attr_float("extrapolation_value", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(CropAndResizeInst { op })
    }
}
impl CropAndResizeInst {
    /// Returns the 'crops' Output of this 'CropAndResize' operation.
    pub fn crops(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'image' Input of this 'CropAndResize' operation.
    pub fn image(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'boxes' Input of this 'CropAndResize' operation.
    pub fn boxes(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'box_ind' Input of this 'CropAndResize' operation.
    pub fn box_ind(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'crop_size' Input of this 'CropAndResize' operation.
    pub fn crop_size(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
}
impl From<CropAndResizeInst> for crate::Operation {
    fn from(inst: CropAndResizeInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `CropAndResize::new().build(image, boxes, box_ind, crop_size, scope)`.
pub fn crop_and_resize<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
>(
    image: O0,
    boxes: O1,
    box_ind: O2,
    crop_size: O3,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    CropAndResize::new().build(image, boxes, box_ind, crop_size, scope)
}

/// Builder for the `CropAndResizeGradBoxes` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct CropAndResizeGradBoxes {
    T: ::std::option::Option<crate::DataType>,
    method: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'CropAndResizeGradBoxes' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct CropAndResizeGradBoxesInst {
    /// An instance of a fully built CropAndResizeGradBoxes Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl CropAndResizeGradBoxes {
    /// Creates a new `CropAndResizeGradBoxes`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `method` attribute.
    pub fn method<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.method = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `CropAndResizeGradBoxes` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
    >(
        &self,
        grads: O0,
        image: O1,
        boxes: O2,
        box_ind: O3,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            grads.into(),
            image.into(),
            boxes.into(),
            box_ind.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        grads: crate::Output,
        image: crate::Output,
        boxes: crate::Output,
        box_ind: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("CropAndResizeGradBoxes", |nd| {
            nd.add_input(grads);
            nd.add_input(image);
            nd.add_input(boxes);
            nd.add_input(box_ind);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.method {
                nd.set_attr_string("method", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'CropAndResizeGradBoxes' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        grads: crate::Output,
        image: crate::Output,
        boxes: crate::Output,
        box_ind: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<CropAndResizeGradBoxesInst> {
        let op = scope.new_operation("CropAndResizeGradBoxes", |builder| {
            builder.add_input(grads);
            builder.add_input(image);
            builder.add_input(boxes);
            builder.add_input(box_ind);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.method {
                builder.set_attr_string("method", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(CropAndResizeGradBoxesInst { op })
    }
}
impl CropAndResizeGradBoxesInst {
    /// Returns the 'output' Output of this 'CropAndResizeGradBoxes' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'grads' Input of this 'CropAndResizeGradBoxes' operation.
    pub fn grads(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'image' Input of this 'CropAndResizeGradBoxes' operation.
    pub fn image(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'boxes' Input of this 'CropAndResizeGradBoxes' operation.
    pub fn boxes(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'box_ind' Input of this 'CropAndResizeGradBoxes' operation.
    pub fn box_ind(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
}
impl From<CropAndResizeGradBoxesInst> for crate::Operation {
    fn from(inst: CropAndResizeGradBoxesInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `CropAndResizeGradBoxes::new().build(grads, image, boxes, box_ind, scope)`.
pub fn crop_and_resize_grad_boxes<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
>(
    grads: O0,
    image: O1,
    boxes: O2,
    box_ind: O3,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    CropAndResizeGradBoxes::new().build(grads, image, boxes, box_ind, scope)
}

/// Builder for the `CropAndResizeGradImage` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct CropAndResizeGradImage {
    T: ::std::option::Option<crate::DataType>,
    method: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'CropAndResizeGradImage' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct CropAndResizeGradImageInst {
    /// An instance of a fully built CropAndResizeGradImage Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl CropAndResizeGradImage {
    /// Creates a new `CropAndResizeGradImage`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `method` attribute.
    pub fn method<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.method = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `CropAndResizeGradImage` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
    >(
        &self,
        grads: O0,
        boxes: O1,
        box_ind: O2,
        image_size: O3,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            grads.into(),
            boxes.into(),
            box_ind.into(),
            image_size.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        grads: crate::Output,
        boxes: crate::Output,
        box_ind: crate::Output,
        image_size: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("CropAndResizeGradImage", |nd| {
            nd.add_input(grads);
            nd.add_input(boxes);
            nd.add_input(box_ind);
            nd.add_input(image_size);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.method {
                nd.set_attr_string("method", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'CropAndResizeGradImage' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        grads: crate::Output,
        boxes: crate::Output,
        box_ind: crate::Output,
        image_size: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<CropAndResizeGradImageInst> {
        let op = scope.new_operation("CropAndResizeGradImage", |builder| {
            builder.add_input(grads);
            builder.add_input(boxes);
            builder.add_input(box_ind);
            builder.add_input(image_size);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.method {
                builder.set_attr_string("method", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(CropAndResizeGradImageInst { op })
    }
}
impl CropAndResizeGradImageInst {
    /// Returns the 'output' Output of this 'CropAndResizeGradImage' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'grads' Input of this 'CropAndResizeGradImage' operation.
    pub fn grads(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'boxes' Input of this 'CropAndResizeGradImage' operation.
    pub fn boxes(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'box_ind' Input of this 'CropAndResizeGradImage' operation.
    pub fn box_ind(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'image_size' Input of this 'CropAndResizeGradImage' operation.
    pub fn image_size(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
}
impl From<CropAndResizeGradImageInst> for crate::Operation {
    fn from(inst: CropAndResizeGradImageInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `CropAndResizeGradImage::new().build(grads, boxes, box_ind, image_size, scope)`.
pub fn crop_and_resize_grad_image<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
>(
    grads: O0,
    boxes: O1,
    box_ind: O2,
    image_size: O3,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    CropAndResizeGradImage::new().build(grads, boxes, box_ind, image_size, scope)
}

/// Builder for the `Cross` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Cross {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Cross' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct CrossInst {
    /// An instance of a fully built Cross Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Cross {
    /// Creates a new `Cross`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Cross` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        a: O0,
        b: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(a.into(), b.into(), scope)
    }
    fn build_impl(
        &self,
        a: crate::Output,
        b: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Cross", |nd| {
            nd.add_input(a);
            nd.add_input(b);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Cross' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        a: crate::Output,
        b: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<CrossInst> {
        let op = scope.new_operation("Cross", |builder| {
            builder.add_input(a);
            builder.add_input(b);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(CrossInst { op })
    }
}
impl CrossInst {
    /// Returns the 'product' Output of this 'Cross' operation.
    pub fn product(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'a' Input of this 'Cross' operation.
    pub fn a(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'b' Input of this 'Cross' operation.
    pub fn b(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<CrossInst> for crate::Operation {
    fn from(inst: CrossInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Cross::new().build(a, b, scope)`.
pub fn cross<O0: ::std::convert::Into<crate::Output>, O1: ::std::convert::Into<crate::Output>>(
    a: O0,
    b: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Cross::new().build(a, b, scope)
}

/// Builder for the `CrossReplicaSum` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct CrossReplicaSum {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'CrossReplicaSum' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct CrossReplicaSumInst {
    /// An instance of a fully built CrossReplicaSum Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl CrossReplicaSum {
    /// Creates a new `CrossReplicaSum`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `CrossReplicaSum` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        group_assignment: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), group_assignment.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        group_assignment: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("CrossReplicaSum", |nd| {
            nd.add_input(input);
            nd.add_input(group_assignment);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'CrossReplicaSum' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        group_assignment: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<CrossReplicaSumInst> {
        let op = scope.new_operation("CrossReplicaSum", |builder| {
            builder.add_input(input);
            builder.add_input(group_assignment);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(CrossReplicaSumInst { op })
    }
}
impl CrossReplicaSumInst {
    /// Returns the 'output' Output of this 'CrossReplicaSum' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'CrossReplicaSum' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'group_assignment' Input of this 'CrossReplicaSum' operation.
    pub fn group_assignment(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<CrossReplicaSumInst> for crate::Operation {
    fn from(inst: CrossReplicaSumInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `CrossReplicaSum::new().build(input, group_assignment, scope)`.
pub fn cross_replica_sum<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    input: O0,
    group_assignment: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    CrossReplicaSum::new().build(input, group_assignment, scope)
}

/// Builder for the `CudnnRNN` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct CudnnRNN {
    T: ::std::option::Option<crate::DataType>,
    rnn_mode: ::std::option::Option<::std::string::String>,
    input_mode: ::std::option::Option<::std::string::String>,
    direction: ::std::option::Option<::std::string::String>,
    dropout: ::std::option::Option<f32>,
    seed: ::std::option::Option<i64>,
    seed2: ::std::option::Option<i64>,
    is_training: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'CudnnRNN' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct CudnnRNNInst {
    /// An instance of a fully built CudnnRNN Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl CudnnRNN {
    /// Creates a new `CudnnRNN`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `rnn_mode` attribute.
    pub fn rnn_mode<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.rnn_mode = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `input_mode` attribute.
    pub fn input_mode<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.input_mode = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `direction` attribute.
    pub fn direction<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.direction = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `dropout` attribute.
    pub fn dropout<ArgType: ::std::convert::Into<f32>>(mut self, value: ArgType) -> Self {
        self.dropout = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `seed` attribute.
    pub fn seed<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.seed = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `seed2` attribute.
    pub fn seed2<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.seed2 = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `is_training` attribute.
    pub fn is_training<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.is_training = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `CudnnRNN` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        input_h: O1,
        input_c: O2,
        params: O3,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            input.into(),
            input_h.into(),
            input_c.into(),
            params.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        input: crate::Output,
        input_h: crate::Output,
        input_c: crate::Output,
        params: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("CudnnRNN", |nd| {
            nd.add_input(input);
            nd.add_input(input_h);
            nd.add_input(input_c);
            nd.add_input(params);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.rnn_mode {
                nd.set_attr_string("rnn_mode", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.input_mode {
                nd.set_attr_string("input_mode", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.direction {
                nd.set_attr_string("direction", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dropout {
                nd.set_attr_float("dropout", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed {
                nd.set_attr_int("seed", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed2 {
                nd.set_attr_int("seed2", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.is_training {
                nd.set_attr_bool("is_training", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'CudnnRNN' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        input_h: crate::Output,
        input_c: crate::Output,
        params: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<CudnnRNNInst> {
        let op = scope.new_operation("CudnnRNN", |builder| {
            builder.add_input(input);
            builder.add_input(input_h);
            builder.add_input(input_c);
            builder.add_input(params);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.rnn_mode {
                builder.set_attr_string("rnn_mode", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.input_mode {
                builder.set_attr_string("input_mode", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.direction {
                builder.set_attr_string("direction", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dropout {
                builder.set_attr_float("dropout", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed {
                builder.set_attr_int("seed", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed2 {
                builder.set_attr_int("seed2", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.is_training {
                builder.set_attr_bool("is_training", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(CudnnRNNInst { op })
    }
}
impl CudnnRNNInst {
    /// Returns the 'output' Output of this 'CudnnRNN' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'output_h' Output of this 'CudnnRNN' operation.
    pub fn output_h(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'output_c' Output of this 'CudnnRNN' operation.
    pub fn output_c(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns the 'reserve_space' Output of this 'CudnnRNN' operation.
    pub fn reserve_space(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 3,
        }
    }
    /// Returns the 'input' Input of this 'CudnnRNN' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'input_h' Input of this 'CudnnRNN' operation.
    pub fn input_h(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'input_c' Input of this 'CudnnRNN' operation.
    pub fn input_c(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'params' Input of this 'CudnnRNN' operation.
    pub fn params(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
}
impl From<CudnnRNNInst> for crate::Operation {
    fn from(inst: CudnnRNNInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `CudnnRNN::new().build(input, input_h, input_c, params, scope)`.
pub fn cudnn_rnn<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
>(
    input: O0,
    input_h: O1,
    input_c: O2,
    params: O3,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    CudnnRNN::new().build(input, input_h, input_c, params, scope)
}

/// Builder for the `CudnnRNNBackprop` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct CudnnRNNBackprop {
    T: ::std::option::Option<crate::DataType>,
    rnn_mode: ::std::option::Option<::std::string::String>,
    input_mode: ::std::option::Option<::std::string::String>,
    direction: ::std::option::Option<::std::string::String>,
    dropout: ::std::option::Option<f32>,
    seed: ::std::option::Option<i64>,
    seed2: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'CudnnRNNBackprop' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct CudnnRNNBackpropInst {
    /// An instance of a fully built CudnnRNNBackprop Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl CudnnRNNBackprop {
    /// Creates a new `CudnnRNNBackprop`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `rnn_mode` attribute.
    pub fn rnn_mode<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.rnn_mode = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `input_mode` attribute.
    pub fn input_mode<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.input_mode = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `direction` attribute.
    pub fn direction<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.direction = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `dropout` attribute.
    pub fn dropout<ArgType: ::std::convert::Into<f32>>(mut self, value: ArgType) -> Self {
        self.dropout = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `seed` attribute.
    pub fn seed<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.seed = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `seed2` attribute.
    pub fn seed2<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.seed2 = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `CudnnRNNBackprop` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
        O6: ::std::convert::Into<crate::Output>,
        O7: ::std::convert::Into<crate::Output>,
        O8: ::std::convert::Into<crate::Output>,
        O9: ::std::convert::Into<crate::Output>,
        O10: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        input_h: O1,
        input_c: O2,
        params: O3,
        output: O4,
        output_h: O5,
        output_c: O6,
        output_backprop: O7,
        output_h_backprop: O8,
        output_c_backprop: O9,
        reserve_space: O10,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            input.into(),
            input_h.into(),
            input_c.into(),
            params.into(),
            output.into(),
            output_h.into(),
            output_c.into(),
            output_backprop.into(),
            output_h_backprop.into(),
            output_c_backprop.into(),
            reserve_space.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        input: crate::Output,
        input_h: crate::Output,
        input_c: crate::Output,
        params: crate::Output,
        output: crate::Output,
        output_h: crate::Output,
        output_c: crate::Output,
        output_backprop: crate::Output,
        output_h_backprop: crate::Output,
        output_c_backprop: crate::Output,
        reserve_space: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("CudnnRNNBackprop", |nd| {
            nd.add_input(input);
            nd.add_input(input_h);
            nd.add_input(input_c);
            nd.add_input(params);
            nd.add_input(output);
            nd.add_input(output_h);
            nd.add_input(output_c);
            nd.add_input(output_backprop);
            nd.add_input(output_h_backprop);
            nd.add_input(output_c_backprop);
            nd.add_input(reserve_space);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.rnn_mode {
                nd.set_attr_string("rnn_mode", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.input_mode {
                nd.set_attr_string("input_mode", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.direction {
                nd.set_attr_string("direction", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dropout {
                nd.set_attr_float("dropout", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed {
                nd.set_attr_int("seed", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed2 {
                nd.set_attr_int("seed2", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'CudnnRNNBackprop' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        input_h: crate::Output,
        input_c: crate::Output,
        params: crate::Output,
        output: crate::Output,
        output_h: crate::Output,
        output_c: crate::Output,
        output_backprop: crate::Output,
        output_h_backprop: crate::Output,
        output_c_backprop: crate::Output,
        reserve_space: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<CudnnRNNBackpropInst> {
        let op = scope.new_operation("CudnnRNNBackprop", |builder| {
            builder.add_input(input);
            builder.add_input(input_h);
            builder.add_input(input_c);
            builder.add_input(params);
            builder.add_input(output);
            builder.add_input(output_h);
            builder.add_input(output_c);
            builder.add_input(output_backprop);
            builder.add_input(output_h_backprop);
            builder.add_input(output_c_backprop);
            builder.add_input(reserve_space);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.rnn_mode {
                builder.set_attr_string("rnn_mode", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.input_mode {
                builder.set_attr_string("input_mode", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.direction {
                builder.set_attr_string("direction", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dropout {
                builder.set_attr_float("dropout", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed {
                builder.set_attr_int("seed", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed2 {
                builder.set_attr_int("seed2", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(CudnnRNNBackpropInst { op })
    }
}
impl CudnnRNNBackpropInst {
    /// Returns the 'input_backprop' Output of this 'CudnnRNNBackprop' operation.
    pub fn input_backprop(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_h_backprop' Output of this 'CudnnRNNBackprop' operation.
    pub fn input_h_backprop(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'input_c_backprop' Output of this 'CudnnRNNBackprop' operation.
    pub fn input_c_backprop(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns the 'params_backprop' Output of this 'CudnnRNNBackprop' operation.
    pub fn params_backprop(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 3,
        }
    }
    /// Returns the 'input' Input of this 'CudnnRNNBackprop' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'input_h' Input of this 'CudnnRNNBackprop' operation.
    pub fn input_h(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'input_c' Input of this 'CudnnRNNBackprop' operation.
    pub fn input_c(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'params' Input of this 'CudnnRNNBackprop' operation.
    pub fn params(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'output' Input of this 'CudnnRNNBackprop' operation.
    pub fn output(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
    /// Returns the 'output_h' Input of this 'CudnnRNNBackprop' operation.
    pub fn output_h(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 5,
        }
    }
    /// Returns the 'output_c' Input of this 'CudnnRNNBackprop' operation.
    pub fn output_c(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 6,
        }
    }
    /// Returns the 'output_backprop' Input of this 'CudnnRNNBackprop' operation.
    pub fn output_backprop(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 7,
        }
    }
    /// Returns the 'output_h_backprop' Input of this 'CudnnRNNBackprop' operation.
    pub fn output_h_backprop(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 8,
        }
    }
    /// Returns the 'output_c_backprop' Input of this 'CudnnRNNBackprop' operation.
    pub fn output_c_backprop(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 9,
        }
    }
    /// Returns the 'reserve_space' Input of this 'CudnnRNNBackprop' operation.
    pub fn reserve_space(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 10,
        }
    }
}
impl From<CudnnRNNBackpropInst> for crate::Operation {
    fn from(inst: CudnnRNNBackpropInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `CudnnRNNBackprop::new().build(input, input_h, input_c, params, output, output_h, output_c, output_backprop, output_h_backprop, output_c_backprop, reserve_space, scope)`.
pub fn cudnn_rnnbackprop<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
    O6: ::std::convert::Into<crate::Output>,
    O7: ::std::convert::Into<crate::Output>,
    O8: ::std::convert::Into<crate::Output>,
    O9: ::std::convert::Into<crate::Output>,
    O10: ::std::convert::Into<crate::Output>,
>(
    input: O0,
    input_h: O1,
    input_c: O2,
    params: O3,
    output: O4,
    output_h: O5,
    output_c: O6,
    output_backprop: O7,
    output_h_backprop: O8,
    output_c_backprop: O9,
    reserve_space: O10,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    CudnnRNNBackprop::new().build(
        input,
        input_h,
        input_c,
        params,
        output,
        output_h,
        output_c,
        output_backprop,
        output_h_backprop,
        output_c_backprop,
        reserve_space,
        scope,
    )
}

/// Builder for the `CudnnRNNBackpropV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct CudnnRNNBackpropV2 {
    T: ::std::option::Option<crate::DataType>,
    rnn_mode: ::std::option::Option<::std::string::String>,
    input_mode: ::std::option::Option<::std::string::String>,
    direction: ::std::option::Option<::std::string::String>,
    dropout: ::std::option::Option<f32>,
    seed: ::std::option::Option<i64>,
    seed2: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'CudnnRNNBackpropV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct CudnnRNNBackpropV2Inst {
    /// An instance of a fully built CudnnRNNBackpropV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl CudnnRNNBackpropV2 {
    /// Creates a new `CudnnRNNBackpropV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `rnn_mode` attribute.
    pub fn rnn_mode<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.rnn_mode = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `input_mode` attribute.
    pub fn input_mode<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.input_mode = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `direction` attribute.
    pub fn direction<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.direction = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `dropout` attribute.
    pub fn dropout<ArgType: ::std::convert::Into<f32>>(mut self, value: ArgType) -> Self {
        self.dropout = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `seed` attribute.
    pub fn seed<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.seed = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `seed2` attribute.
    pub fn seed2<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.seed2 = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `CudnnRNNBackpropV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
        O6: ::std::convert::Into<crate::Output>,
        O7: ::std::convert::Into<crate::Output>,
        O8: ::std::convert::Into<crate::Output>,
        O9: ::std::convert::Into<crate::Output>,
        O10: ::std::convert::Into<crate::Output>,
        O11: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        input_h: O1,
        input_c: O2,
        params: O3,
        output: O4,
        output_h: O5,
        output_c: O6,
        output_backprop: O7,
        output_h_backprop: O8,
        output_c_backprop: O9,
        reserve_space: O10,
        host_reserved: O11,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            input.into(),
            input_h.into(),
            input_c.into(),
            params.into(),
            output.into(),
            output_h.into(),
            output_c.into(),
            output_backprop.into(),
            output_h_backprop.into(),
            output_c_backprop.into(),
            reserve_space.into(),
            host_reserved.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        input: crate::Output,
        input_h: crate::Output,
        input_c: crate::Output,
        params: crate::Output,
        output: crate::Output,
        output_h: crate::Output,
        output_c: crate::Output,
        output_backprop: crate::Output,
        output_h_backprop: crate::Output,
        output_c_backprop: crate::Output,
        reserve_space: crate::Output,
        host_reserved: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("CudnnRNNBackpropV2", |nd| {
            nd.add_input(input);
            nd.add_input(input_h);
            nd.add_input(input_c);
            nd.add_input(params);
            nd.add_input(output);
            nd.add_input(output_h);
            nd.add_input(output_c);
            nd.add_input(output_backprop);
            nd.add_input(output_h_backprop);
            nd.add_input(output_c_backprop);
            nd.add_input(reserve_space);
            nd.add_input(host_reserved);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.rnn_mode {
                nd.set_attr_string("rnn_mode", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.input_mode {
                nd.set_attr_string("input_mode", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.direction {
                nd.set_attr_string("direction", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dropout {
                nd.set_attr_float("dropout", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed {
                nd.set_attr_int("seed", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed2 {
                nd.set_attr_int("seed2", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'CudnnRNNBackpropV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        input_h: crate::Output,
        input_c: crate::Output,
        params: crate::Output,
        output: crate::Output,
        output_h: crate::Output,
        output_c: crate::Output,
        output_backprop: crate::Output,
        output_h_backprop: crate::Output,
        output_c_backprop: crate::Output,
        reserve_space: crate::Output,
        host_reserved: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<CudnnRNNBackpropV2Inst> {
        let op = scope.new_operation("CudnnRNNBackpropV2", |builder| {
            builder.add_input(input);
            builder.add_input(input_h);
            builder.add_input(input_c);
            builder.add_input(params);
            builder.add_input(output);
            builder.add_input(output_h);
            builder.add_input(output_c);
            builder.add_input(output_backprop);
            builder.add_input(output_h_backprop);
            builder.add_input(output_c_backprop);
            builder.add_input(reserve_space);
            builder.add_input(host_reserved);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.rnn_mode {
                builder.set_attr_string("rnn_mode", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.input_mode {
                builder.set_attr_string("input_mode", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.direction {
                builder.set_attr_string("direction", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dropout {
                builder.set_attr_float("dropout", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed {
                builder.set_attr_int("seed", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed2 {
                builder.set_attr_int("seed2", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(CudnnRNNBackpropV2Inst { op })
    }
}
impl CudnnRNNBackpropV2Inst {
    /// Returns the 'input_backprop' Output of this 'CudnnRNNBackpropV2' operation.
    pub fn input_backprop(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_h_backprop' Output of this 'CudnnRNNBackpropV2' operation.
    pub fn input_h_backprop(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'input_c_backprop' Output of this 'CudnnRNNBackpropV2' operation.
    pub fn input_c_backprop(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns the 'params_backprop' Output of this 'CudnnRNNBackpropV2' operation.
    pub fn params_backprop(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 3,
        }
    }
    /// Returns the 'input' Input of this 'CudnnRNNBackpropV2' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'input_h' Input of this 'CudnnRNNBackpropV2' operation.
    pub fn input_h(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'input_c' Input of this 'CudnnRNNBackpropV2' operation.
    pub fn input_c(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'params' Input of this 'CudnnRNNBackpropV2' operation.
    pub fn params(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'output' Input of this 'CudnnRNNBackpropV2' operation.
    pub fn output(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
    /// Returns the 'output_h' Input of this 'CudnnRNNBackpropV2' operation.
    pub fn output_h(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 5,
        }
    }
    /// Returns the 'output_c' Input of this 'CudnnRNNBackpropV2' operation.
    pub fn output_c(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 6,
        }
    }
    /// Returns the 'output_backprop' Input of this 'CudnnRNNBackpropV2' operation.
    pub fn output_backprop(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 7,
        }
    }
    /// Returns the 'output_h_backprop' Input of this 'CudnnRNNBackpropV2' operation.
    pub fn output_h_backprop(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 8,
        }
    }
    /// Returns the 'output_c_backprop' Input of this 'CudnnRNNBackpropV2' operation.
    pub fn output_c_backprop(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 9,
        }
    }
    /// Returns the 'reserve_space' Input of this 'CudnnRNNBackpropV2' operation.
    pub fn reserve_space(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 10,
        }
    }
    /// Returns the 'host_reserved' Input of this 'CudnnRNNBackpropV2' operation.
    pub fn host_reserved(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 11,
        }
    }
}
impl From<CudnnRNNBackpropV2Inst> for crate::Operation {
    fn from(inst: CudnnRNNBackpropV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `CudnnRNNBackpropV2::new().build(input, input_h, input_c, params, output, output_h, output_c, output_backprop, output_h_backprop, output_c_backprop, reserve_space, host_reserved, scope)`.
pub fn cudnn_rnnbackprop_v2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
    O6: ::std::convert::Into<crate::Output>,
    O7: ::std::convert::Into<crate::Output>,
    O8: ::std::convert::Into<crate::Output>,
    O9: ::std::convert::Into<crate::Output>,
    O10: ::std::convert::Into<crate::Output>,
    O11: ::std::convert::Into<crate::Output>,
>(
    input: O0,
    input_h: O1,
    input_c: O2,
    params: O3,
    output: O4,
    output_h: O5,
    output_c: O6,
    output_backprop: O7,
    output_h_backprop: O8,
    output_c_backprop: O9,
    reserve_space: O10,
    host_reserved: O11,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    CudnnRNNBackpropV2::new().build(
        input,
        input_h,
        input_c,
        params,
        output,
        output_h,
        output_c,
        output_backprop,
        output_h_backprop,
        output_c_backprop,
        reserve_space,
        host_reserved,
        scope,
    )
}

/// Builder for the `CudnnRNNBackpropV3` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct CudnnRNNBackpropV3 {
    T: ::std::option::Option<crate::DataType>,
    rnn_mode: ::std::option::Option<::std::string::String>,
    input_mode: ::std::option::Option<::std::string::String>,
    direction: ::std::option::Option<::std::string::String>,
    dropout: ::std::option::Option<f32>,
    seed: ::std::option::Option<i64>,
    seed2: ::std::option::Option<i64>,
    num_proj: ::std::option::Option<i64>,
    time_major: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'CudnnRNNBackpropV3' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct CudnnRNNBackpropV3Inst {
    /// An instance of a fully built CudnnRNNBackpropV3 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl CudnnRNNBackpropV3 {
    /// Creates a new `CudnnRNNBackpropV3`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `rnn_mode` attribute.
    pub fn rnn_mode<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.rnn_mode = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `input_mode` attribute.
    pub fn input_mode<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.input_mode = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `direction` attribute.
    pub fn direction<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.direction = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `dropout` attribute.
    pub fn dropout<ArgType: ::std::convert::Into<f32>>(mut self, value: ArgType) -> Self {
        self.dropout = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `seed` attribute.
    pub fn seed<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.seed = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `seed2` attribute.
    pub fn seed2<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.seed2 = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `num_proj` attribute.
    pub fn num_proj<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.num_proj = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `time_major` attribute.
    pub fn time_major<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.time_major = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `CudnnRNNBackpropV3` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
        O6: ::std::convert::Into<crate::Output>,
        O7: ::std::convert::Into<crate::Output>,
        O8: ::std::convert::Into<crate::Output>,
        O9: ::std::convert::Into<crate::Output>,
        O10: ::std::convert::Into<crate::Output>,
        O11: ::std::convert::Into<crate::Output>,
        O12: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        input_h: O1,
        input_c: O2,
        params: O3,
        sequence_lengths: O4,
        output: O5,
        output_h: O6,
        output_c: O7,
        output_backprop: O8,
        output_h_backprop: O9,
        output_c_backprop: O10,
        reserve_space: O11,
        host_reserved: O12,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            input.into(),
            input_h.into(),
            input_c.into(),
            params.into(),
            sequence_lengths.into(),
            output.into(),
            output_h.into(),
            output_c.into(),
            output_backprop.into(),
            output_h_backprop.into(),
            output_c_backprop.into(),
            reserve_space.into(),
            host_reserved.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        input: crate::Output,
        input_h: crate::Output,
        input_c: crate::Output,
        params: crate::Output,
        sequence_lengths: crate::Output,
        output: crate::Output,
        output_h: crate::Output,
        output_c: crate::Output,
        output_backprop: crate::Output,
        output_h_backprop: crate::Output,
        output_c_backprop: crate::Output,
        reserve_space: crate::Output,
        host_reserved: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("CudnnRNNBackpropV3", |nd| {
            nd.add_input(input);
            nd.add_input(input_h);
            nd.add_input(input_c);
            nd.add_input(params);
            nd.add_input(sequence_lengths);
            nd.add_input(output);
            nd.add_input(output_h);
            nd.add_input(output_c);
            nd.add_input(output_backprop);
            nd.add_input(output_h_backprop);
            nd.add_input(output_c_backprop);
            nd.add_input(reserve_space);
            nd.add_input(host_reserved);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.rnn_mode {
                nd.set_attr_string("rnn_mode", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.input_mode {
                nd.set_attr_string("input_mode", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.direction {
                nd.set_attr_string("direction", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dropout {
                nd.set_attr_float("dropout", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed {
                nd.set_attr_int("seed", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed2 {
                nd.set_attr_int("seed2", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_proj {
                nd.set_attr_int("num_proj", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.time_major {
                nd.set_attr_bool("time_major", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'CudnnRNNBackpropV3' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        input_h: crate::Output,
        input_c: crate::Output,
        params: crate::Output,
        sequence_lengths: crate::Output,
        output: crate::Output,
        output_h: crate::Output,
        output_c: crate::Output,
        output_backprop: crate::Output,
        output_h_backprop: crate::Output,
        output_c_backprop: crate::Output,
        reserve_space: crate::Output,
        host_reserved: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<CudnnRNNBackpropV3Inst> {
        let op = scope.new_operation("CudnnRNNBackpropV3", |builder| {
            builder.add_input(input);
            builder.add_input(input_h);
            builder.add_input(input_c);
            builder.add_input(params);
            builder.add_input(sequence_lengths);
            builder.add_input(output);
            builder.add_input(output_h);
            builder.add_input(output_c);
            builder.add_input(output_backprop);
            builder.add_input(output_h_backprop);
            builder.add_input(output_c_backprop);
            builder.add_input(reserve_space);
            builder.add_input(host_reserved);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.rnn_mode {
                builder.set_attr_string("rnn_mode", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.input_mode {
                builder.set_attr_string("input_mode", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.direction {
                builder.set_attr_string("direction", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dropout {
                builder.set_attr_float("dropout", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed {
                builder.set_attr_int("seed", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed2 {
                builder.set_attr_int("seed2", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_proj {
                builder.set_attr_int("num_proj", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.time_major {
                builder.set_attr_bool("time_major", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(CudnnRNNBackpropV3Inst { op })
    }
}
impl CudnnRNNBackpropV3Inst {
    /// Returns the 'input_backprop' Output of this 'CudnnRNNBackpropV3' operation.
    pub fn input_backprop(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_h_backprop' Output of this 'CudnnRNNBackpropV3' operation.
    pub fn input_h_backprop(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'input_c_backprop' Output of this 'CudnnRNNBackpropV3' operation.
    pub fn input_c_backprop(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns the 'params_backprop' Output of this 'CudnnRNNBackpropV3' operation.
    pub fn params_backprop(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 3,
        }
    }
    /// Returns the 'input' Input of this 'CudnnRNNBackpropV3' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'input_h' Input of this 'CudnnRNNBackpropV3' operation.
    pub fn input_h(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'input_c' Input of this 'CudnnRNNBackpropV3' operation.
    pub fn input_c(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'params' Input of this 'CudnnRNNBackpropV3' operation.
    pub fn params(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'sequence_lengths' Input of this 'CudnnRNNBackpropV3' operation.
    pub fn sequence_lengths(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
    /// Returns the 'output' Input of this 'CudnnRNNBackpropV3' operation.
    pub fn output(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 5,
        }
    }
    /// Returns the 'output_h' Input of this 'CudnnRNNBackpropV3' operation.
    pub fn output_h(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 6,
        }
    }
    /// Returns the 'output_c' Input of this 'CudnnRNNBackpropV3' operation.
    pub fn output_c(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 7,
        }
    }
    /// Returns the 'output_backprop' Input of this 'CudnnRNNBackpropV3' operation.
    pub fn output_backprop(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 8,
        }
    }
    /// Returns the 'output_h_backprop' Input of this 'CudnnRNNBackpropV3' operation.
    pub fn output_h_backprop(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 9,
        }
    }
    /// Returns the 'output_c_backprop' Input of this 'CudnnRNNBackpropV3' operation.
    pub fn output_c_backprop(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 10,
        }
    }
    /// Returns the 'reserve_space' Input of this 'CudnnRNNBackpropV3' operation.
    pub fn reserve_space(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 11,
        }
    }
    /// Returns the 'host_reserved' Input of this 'CudnnRNNBackpropV3' operation.
    pub fn host_reserved(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 12,
        }
    }
}
impl From<CudnnRNNBackpropV3Inst> for crate::Operation {
    fn from(inst: CudnnRNNBackpropV3Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `CudnnRNNBackpropV3::new().build(input, input_h, input_c, params, sequence_lengths, output, output_h, output_c, output_backprop, output_h_backprop, output_c_backprop, reserve_space, host_reserved, scope)`.
pub fn cudnn_rnnbackprop_v3<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
    O6: ::std::convert::Into<crate::Output>,
    O7: ::std::convert::Into<crate::Output>,
    O8: ::std::convert::Into<crate::Output>,
    O9: ::std::convert::Into<crate::Output>,
    O10: ::std::convert::Into<crate::Output>,
    O11: ::std::convert::Into<crate::Output>,
    O12: ::std::convert::Into<crate::Output>,
>(
    input: O0,
    input_h: O1,
    input_c: O2,
    params: O3,
    sequence_lengths: O4,
    output: O5,
    output_h: O6,
    output_c: O7,
    output_backprop: O8,
    output_h_backprop: O9,
    output_c_backprop: O10,
    reserve_space: O11,
    host_reserved: O12,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    CudnnRNNBackpropV3::new().build(
        input,
        input_h,
        input_c,
        params,
        sequence_lengths,
        output,
        output_h,
        output_c,
        output_backprop,
        output_h_backprop,
        output_c_backprop,
        reserve_space,
        host_reserved,
        scope,
    )
}

/// Builder for the `CudnnRNNCanonicalToParams` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct CudnnRNNCanonicalToParams {
    T: ::std::option::Option<crate::DataType>,
    num_params: ::std::option::Option<i64>,
    rnn_mode: ::std::option::Option<::std::string::String>,
    input_mode: ::std::option::Option<::std::string::String>,
    direction: ::std::option::Option<::std::string::String>,
    dropout: ::std::option::Option<f32>,
    seed: ::std::option::Option<i64>,
    seed2: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'CudnnRNNCanonicalToParams' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct CudnnRNNCanonicalToParamsInst {
    /// An instance of a fully built CudnnRNNCanonicalToParams Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl CudnnRNNCanonicalToParams {
    /// Creates a new `CudnnRNNCanonicalToParams`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `num_params` attribute.
    pub fn num_params<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.num_params = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `rnn_mode` attribute.
    pub fn rnn_mode<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.rnn_mode = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `input_mode` attribute.
    pub fn input_mode<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.input_mode = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `direction` attribute.
    pub fn direction<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.direction = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `dropout` attribute.
    pub fn dropout<ArgType: ::std::convert::Into<f32>>(mut self, value: ArgType) -> Self {
        self.dropout = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `seed` attribute.
    pub fn seed<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.seed = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `seed2` attribute.
    pub fn seed2<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.seed2 = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `CudnnRNNCanonicalToParams` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
    >(
        &self,
        num_layers: O0,
        num_units: O1,
        input_size: O2,
        weights: O3,
        biases: O4,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            num_layers.into(),
            num_units.into(),
            input_size.into(),
            weights.into(),
            biases.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        num_layers: crate::Output,
        num_units: crate::Output,
        input_size: crate::Output,
        weights: crate::Output,
        biases: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("CudnnRNNCanonicalToParams", |nd| {
            nd.add_input(num_layers);
            nd.add_input(num_units);
            nd.add_input(input_size);
            nd.add_input(weights);
            nd.add_input(biases);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_params {
                nd.set_attr_int("num_params", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.rnn_mode {
                nd.set_attr_string("rnn_mode", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.input_mode {
                nd.set_attr_string("input_mode", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.direction {
                nd.set_attr_string("direction", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dropout {
                nd.set_attr_float("dropout", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed {
                nd.set_attr_int("seed", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed2 {
                nd.set_attr_int("seed2", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'CudnnRNNCanonicalToParams' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        num_layers: crate::Output,
        num_units: crate::Output,
        input_size: crate::Output,
        weights: Vec<crate::Output>,
        biases: Vec<crate::Output>,
        scope: &mut crate::Scope,
    ) -> crate::Result<CudnnRNNCanonicalToParamsInst> {
        let op = scope.new_operation("CudnnRNNCanonicalToParams", |builder| {
            builder.add_input(num_layers);
            builder.add_input(num_units);
            builder.add_input(input_size);
            builder.add_input_list(&weights);
            builder.add_input_list(&biases);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            builder.set_attr_int("num_params", weights.clone().len() as i64)?;
            if let ::std::option::Option::Some(value) = &self.rnn_mode {
                builder.set_attr_string("rnn_mode", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.input_mode {
                builder.set_attr_string("input_mode", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.direction {
                builder.set_attr_string("direction", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dropout {
                builder.set_attr_float("dropout", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed {
                builder.set_attr_int("seed", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed2 {
                builder.set_attr_int("seed2", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(CudnnRNNCanonicalToParamsInst { op })
    }
}
impl CudnnRNNCanonicalToParamsInst {
    /// Returns the 'params' Output of this 'CudnnRNNCanonicalToParams' operation.
    pub fn params(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'num_layers' Input of this 'CudnnRNNCanonicalToParams' operation.
    pub fn num_layers(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'num_units' Input of this 'CudnnRNNCanonicalToParams' operation.
    pub fn num_units(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'input_size' Input of this 'CudnnRNNCanonicalToParams' operation.
    pub fn input_size(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns a Vector of weights for 'weights' Input of this CudnnRNNCanonicalToParams operation.
    pub fn weights(&self) -> crate::Result<Vec<crate::Input>> {
        let mut Inputs = vec![];
        for i in 3..self.op.get_attr_int("num_params")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
    /// Returns a Vector of biases for 'biases' Input of this CudnnRNNCanonicalToParams operation.
    pub fn biases(&self) -> crate::Result<Vec<crate::Input>> {
        let dynamic_offset = (self.op.get_attr_int("num_params")? + 4) as i32;
        let mut Inputs = vec![];
        for i in dynamic_offset..dynamic_offset + self.op.get_attr_int("num_params")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
}
impl From<CudnnRNNCanonicalToParamsInst> for crate::Operation {
    fn from(inst: CudnnRNNCanonicalToParamsInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `CudnnRNNCanonicalToParams::new().build(num_layers, num_units, input_size, weights, biases, scope)`.
pub fn cudnn_rnncanonical_to_params<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
>(
    num_layers: O0,
    num_units: O1,
    input_size: O2,
    weights: O3,
    biases: O4,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    CudnnRNNCanonicalToParams::new()
        .build(num_layers, num_units, input_size, weights, biases, scope)
}

/// Builder for the `CudnnRNNCanonicalToParamsV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct CudnnRNNCanonicalToParamsV2 {
    T: ::std::option::Option<crate::DataType>,
    num_params_weights: ::std::option::Option<i64>,
    num_params_biases: ::std::option::Option<i64>,
    rnn_mode: ::std::option::Option<::std::string::String>,
    input_mode: ::std::option::Option<::std::string::String>,
    direction: ::std::option::Option<::std::string::String>,
    dropout: ::std::option::Option<f32>,
    seed: ::std::option::Option<i64>,
    seed2: ::std::option::Option<i64>,
    num_proj: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'CudnnRNNCanonicalToParamsV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct CudnnRNNCanonicalToParamsV2Inst {
    /// An instance of a fully built CudnnRNNCanonicalToParamsV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl CudnnRNNCanonicalToParamsV2 {
    /// Creates a new `CudnnRNNCanonicalToParamsV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `num_params_weights` attribute.
    pub fn num_params_weights<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.num_params_weights = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `num_params_biases` attribute.
    pub fn num_params_biases<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.num_params_biases = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `rnn_mode` attribute.
    pub fn rnn_mode<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.rnn_mode = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `input_mode` attribute.
    pub fn input_mode<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.input_mode = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `direction` attribute.
    pub fn direction<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.direction = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `dropout` attribute.
    pub fn dropout<ArgType: ::std::convert::Into<f32>>(mut self, value: ArgType) -> Self {
        self.dropout = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `seed` attribute.
    pub fn seed<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.seed = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `seed2` attribute.
    pub fn seed2<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.seed2 = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `num_proj` attribute.
    pub fn num_proj<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.num_proj = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `CudnnRNNCanonicalToParamsV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
    >(
        &self,
        num_layers: O0,
        num_units: O1,
        input_size: O2,
        weights: O3,
        biases: O4,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            num_layers.into(),
            num_units.into(),
            input_size.into(),
            weights.into(),
            biases.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        num_layers: crate::Output,
        num_units: crate::Output,
        input_size: crate::Output,
        weights: crate::Output,
        biases: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("CudnnRNNCanonicalToParamsV2", |nd| {
            nd.add_input(num_layers);
            nd.add_input(num_units);
            nd.add_input(input_size);
            nd.add_input(weights);
            nd.add_input(biases);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_params_weights {
                nd.set_attr_int("num_params_weights", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_params_biases {
                nd.set_attr_int("num_params_biases", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.rnn_mode {
                nd.set_attr_string("rnn_mode", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.input_mode {
                nd.set_attr_string("input_mode", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.direction {
                nd.set_attr_string("direction", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dropout {
                nd.set_attr_float("dropout", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed {
                nd.set_attr_int("seed", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed2 {
                nd.set_attr_int("seed2", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_proj {
                nd.set_attr_int("num_proj", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'CudnnRNNCanonicalToParamsV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        num_layers: crate::Output,
        num_units: crate::Output,
        input_size: crate::Output,
        weights: Vec<crate::Output>,
        biases: Vec<crate::Output>,
        scope: &mut crate::Scope,
    ) -> crate::Result<CudnnRNNCanonicalToParamsV2Inst> {
        let op = scope.new_operation("CudnnRNNCanonicalToParamsV2", |builder| {
            builder.add_input(num_layers);
            builder.add_input(num_units);
            builder.add_input(input_size);
            builder.add_input_list(&weights);
            builder.add_input_list(&biases);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            builder.set_attr_int("num_params_weights", weights.clone().len() as i64)?;
            builder.set_attr_int("num_params_biases", biases.clone().len() as i64)?;
            if let ::std::option::Option::Some(value) = &self.rnn_mode {
                builder.set_attr_string("rnn_mode", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.input_mode {
                builder.set_attr_string("input_mode", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.direction {
                builder.set_attr_string("direction", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dropout {
                builder.set_attr_float("dropout", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed {
                builder.set_attr_int("seed", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed2 {
                builder.set_attr_int("seed2", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_proj {
                builder.set_attr_int("num_proj", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(CudnnRNNCanonicalToParamsV2Inst { op })
    }
}
impl CudnnRNNCanonicalToParamsV2Inst {
    /// Returns the 'params' Output of this 'CudnnRNNCanonicalToParamsV2' operation.
    pub fn params(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'num_layers' Input of this 'CudnnRNNCanonicalToParamsV2' operation.
    pub fn num_layers(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'num_units' Input of this 'CudnnRNNCanonicalToParamsV2' operation.
    pub fn num_units(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'input_size' Input of this 'CudnnRNNCanonicalToParamsV2' operation.
    pub fn input_size(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns a Vector of weights for 'weights' Input of this CudnnRNNCanonicalToParamsV2 operation.
    pub fn weights(&self) -> crate::Result<Vec<crate::Input>> {
        let mut Inputs = vec![];
        for i in 3..self.op.get_attr_int("num_params_weights")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
    /// Returns a Vector of biases for 'biases' Input of this CudnnRNNCanonicalToParamsV2 operation.
    pub fn biases(&self) -> crate::Result<Vec<crate::Input>> {
        let dynamic_offset = (self.op.get_attr_int("num_params_weights")? + 4) as i32;
        let mut Inputs = vec![];
        for i in dynamic_offset..dynamic_offset + self.op.get_attr_int("num_params_biases")? as i32
        {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
}
impl From<CudnnRNNCanonicalToParamsV2Inst> for crate::Operation {
    fn from(inst: CudnnRNNCanonicalToParamsV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `CudnnRNNCanonicalToParamsV2::new().build(num_layers, num_units, input_size, weights, biases, scope)`.
pub fn cudnn_rnncanonical_to_params_v2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
>(
    num_layers: O0,
    num_units: O1,
    input_size: O2,
    weights: O3,
    biases: O4,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    CudnnRNNCanonicalToParamsV2::new()
        .build(num_layers, num_units, input_size, weights, biases, scope)
}

/// Builder for the `CudnnRNNParamsSize` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct CudnnRNNParamsSize {
    T: ::std::option::Option<crate::DataType>,
    S: ::std::option::Option<crate::DataType>,
    rnn_mode: ::std::option::Option<::std::string::String>,
    input_mode: ::std::option::Option<::std::string::String>,
    direction: ::std::option::Option<::std::string::String>,
    dropout: ::std::option::Option<f32>,
    seed: ::std::option::Option<i64>,
    seed2: ::std::option::Option<i64>,
    num_proj: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'CudnnRNNParamsSize' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct CudnnRNNParamsSizeInst {
    /// An instance of a fully built CudnnRNNParamsSize Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl CudnnRNNParamsSize {
    /// Creates a new `CudnnRNNParamsSize`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `S` attribute.
    pub fn S<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.S = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `rnn_mode` attribute.
    pub fn rnn_mode<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.rnn_mode = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `input_mode` attribute.
    pub fn input_mode<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.input_mode = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `direction` attribute.
    pub fn direction<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.direction = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `dropout` attribute.
    pub fn dropout<ArgType: ::std::convert::Into<f32>>(mut self, value: ArgType) -> Self {
        self.dropout = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `seed` attribute.
    pub fn seed<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.seed = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `seed2` attribute.
    pub fn seed2<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.seed2 = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `num_proj` attribute.
    pub fn num_proj<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.num_proj = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `CudnnRNNParamsSize` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        num_layers: O0,
        num_units: O1,
        input_size: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            num_layers.into(),
            num_units.into(),
            input_size.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        num_layers: crate::Output,
        num_units: crate::Output,
        input_size: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("CudnnRNNParamsSize", |nd| {
            nd.add_input(num_layers);
            nd.add_input(num_units);
            nd.add_input(input_size);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.S {
                nd.set_attr_type("S", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.rnn_mode {
                nd.set_attr_string("rnn_mode", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.input_mode {
                nd.set_attr_string("input_mode", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.direction {
                nd.set_attr_string("direction", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dropout {
                nd.set_attr_float("dropout", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed {
                nd.set_attr_int("seed", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed2 {
                nd.set_attr_int("seed2", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_proj {
                nd.set_attr_int("num_proj", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'CudnnRNNParamsSize' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        num_layers: crate::Output,
        num_units: crate::Output,
        input_size: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<CudnnRNNParamsSizeInst> {
        let op = scope.new_operation("CudnnRNNParamsSize", |builder| {
            builder.add_input(num_layers);
            builder.add_input(num_units);
            builder.add_input(input_size);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.S {
                builder.set_attr_type("S", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.rnn_mode {
                builder.set_attr_string("rnn_mode", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.input_mode {
                builder.set_attr_string("input_mode", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.direction {
                builder.set_attr_string("direction", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dropout {
                builder.set_attr_float("dropout", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed {
                builder.set_attr_int("seed", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed2 {
                builder.set_attr_int("seed2", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_proj {
                builder.set_attr_int("num_proj", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(CudnnRNNParamsSizeInst { op })
    }
}
impl CudnnRNNParamsSizeInst {
    /// Returns the 'params_size' Output of this 'CudnnRNNParamsSize' operation.
    pub fn params_size(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'num_layers' Input of this 'CudnnRNNParamsSize' operation.
    pub fn num_layers(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'num_units' Input of this 'CudnnRNNParamsSize' operation.
    pub fn num_units(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'input_size' Input of this 'CudnnRNNParamsSize' operation.
    pub fn input_size(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<CudnnRNNParamsSizeInst> for crate::Operation {
    fn from(inst: CudnnRNNParamsSizeInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `CudnnRNNParamsSize::new().build(num_layers, num_units, input_size, scope)`.
pub fn cudnn_rnnparams_size<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    num_layers: O0,
    num_units: O1,
    input_size: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    CudnnRNNParamsSize::new().build(num_layers, num_units, input_size, scope)
}

/// Builder for the `CudnnRNNParamsToCanonical` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct CudnnRNNParamsToCanonical {
    T: ::std::option::Option<crate::DataType>,
    num_params: ::std::option::Option<i64>,
    rnn_mode: ::std::option::Option<::std::string::String>,
    input_mode: ::std::option::Option<::std::string::String>,
    direction: ::std::option::Option<::std::string::String>,
    dropout: ::std::option::Option<f32>,
    seed: ::std::option::Option<i64>,
    seed2: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'CudnnRNNParamsToCanonical' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct CudnnRNNParamsToCanonicalInst {
    /// An instance of a fully built CudnnRNNParamsToCanonical Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl CudnnRNNParamsToCanonical {
    /// Creates a new `CudnnRNNParamsToCanonical`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `num_params` attribute.
    pub fn num_params<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.num_params = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `rnn_mode` attribute.
    pub fn rnn_mode<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.rnn_mode = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `input_mode` attribute.
    pub fn input_mode<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.input_mode = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `direction` attribute.
    pub fn direction<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.direction = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `dropout` attribute.
    pub fn dropout<ArgType: ::std::convert::Into<f32>>(mut self, value: ArgType) -> Self {
        self.dropout = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `seed` attribute.
    pub fn seed<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.seed = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `seed2` attribute.
    pub fn seed2<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.seed2 = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `CudnnRNNParamsToCanonical` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
    >(
        &self,
        num_layers: O0,
        num_units: O1,
        input_size: O2,
        params: O3,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            num_layers.into(),
            num_units.into(),
            input_size.into(),
            params.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        num_layers: crate::Output,
        num_units: crate::Output,
        input_size: crate::Output,
        params: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("CudnnRNNParamsToCanonical", |nd| {
            nd.add_input(num_layers);
            nd.add_input(num_units);
            nd.add_input(input_size);
            nd.add_input(params);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_params {
                nd.set_attr_int("num_params", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.rnn_mode {
                nd.set_attr_string("rnn_mode", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.input_mode {
                nd.set_attr_string("input_mode", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.direction {
                nd.set_attr_string("direction", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dropout {
                nd.set_attr_float("dropout", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed {
                nd.set_attr_int("seed", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed2 {
                nd.set_attr_int("seed2", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'CudnnRNNParamsToCanonical' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        num_layers: crate::Output,
        num_units: crate::Output,
        input_size: crate::Output,
        params: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<CudnnRNNParamsToCanonicalInst> {
        let op = scope.new_operation("CudnnRNNParamsToCanonical", |builder| {
            builder.add_input(num_layers);
            builder.add_input(num_units);
            builder.add_input(input_size);
            builder.add_input(params);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_params {
                builder.set_attr_int("num_params", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.rnn_mode {
                builder.set_attr_string("rnn_mode", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.input_mode {
                builder.set_attr_string("input_mode", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.direction {
                builder.set_attr_string("direction", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dropout {
                builder.set_attr_float("dropout", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed {
                builder.set_attr_int("seed", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed2 {
                builder.set_attr_int("seed2", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(CudnnRNNParamsToCanonicalInst { op })
    }
}
impl CudnnRNNParamsToCanonicalInst {
    /// Returns a Vector of weights for 'weights' Output of this CudnnRNNParamsToCanonical operation.
    pub fn weights(&self) -> crate::Result<Vec<crate::Output>> {
        let mut Outputs = vec![];
        for i in 0..self.op.get_attr_int("num_params")? as i32 {
            Outputs.push(crate::Output {
                operation: self.op.clone(),
                index: i,
            });
        }
        Ok(Outputs)
    }
    /// Returns a Vector of biases for 'biases' Output of this CudnnRNNParamsToCanonical operation.
    pub fn biases(&self) -> crate::Result<Vec<crate::Output>> {
        let dynamic_offset = (self.op.get_attr_int("num_params")? + 1) as i32;
        let mut Outputs = vec![];
        for i in dynamic_offset..dynamic_offset + self.op.get_attr_int("num_params")? as i32 {
            Outputs.push(crate::Output {
                operation: self.op.clone(),
                index: i,
            });
        }
        Ok(Outputs)
    }
    /// Returns the 'num_layers' Input of this 'CudnnRNNParamsToCanonical' operation.
    pub fn num_layers(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'num_units' Input of this 'CudnnRNNParamsToCanonical' operation.
    pub fn num_units(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'input_size' Input of this 'CudnnRNNParamsToCanonical' operation.
    pub fn input_size(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'params' Input of this 'CudnnRNNParamsToCanonical' operation.
    pub fn params(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
}
impl From<CudnnRNNParamsToCanonicalInst> for crate::Operation {
    fn from(inst: CudnnRNNParamsToCanonicalInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `CudnnRNNParamsToCanonical::new().build(num_layers, num_units, input_size, params, scope)`.
pub fn cudnn_rnnparams_to_canonical<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
>(
    num_layers: O0,
    num_units: O1,
    input_size: O2,
    params: O3,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    CudnnRNNParamsToCanonical::new().build(num_layers, num_units, input_size, params, scope)
}

/// Builder for the `CudnnRNNParamsToCanonicalV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct CudnnRNNParamsToCanonicalV2 {
    T: ::std::option::Option<crate::DataType>,
    num_params_weights: ::std::option::Option<i64>,
    num_params_biases: ::std::option::Option<i64>,
    rnn_mode: ::std::option::Option<::std::string::String>,
    input_mode: ::std::option::Option<::std::string::String>,
    direction: ::std::option::Option<::std::string::String>,
    dropout: ::std::option::Option<f32>,
    seed: ::std::option::Option<i64>,
    seed2: ::std::option::Option<i64>,
    num_proj: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'CudnnRNNParamsToCanonicalV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct CudnnRNNParamsToCanonicalV2Inst {
    /// An instance of a fully built CudnnRNNParamsToCanonicalV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl CudnnRNNParamsToCanonicalV2 {
    /// Creates a new `CudnnRNNParamsToCanonicalV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `num_params_weights` attribute.
    pub fn num_params_weights<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.num_params_weights = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `num_params_biases` attribute.
    pub fn num_params_biases<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.num_params_biases = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `rnn_mode` attribute.
    pub fn rnn_mode<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.rnn_mode = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `input_mode` attribute.
    pub fn input_mode<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.input_mode = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `direction` attribute.
    pub fn direction<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.direction = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `dropout` attribute.
    pub fn dropout<ArgType: ::std::convert::Into<f32>>(mut self, value: ArgType) -> Self {
        self.dropout = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `seed` attribute.
    pub fn seed<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.seed = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `seed2` attribute.
    pub fn seed2<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.seed2 = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `num_proj` attribute.
    pub fn num_proj<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.num_proj = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `CudnnRNNParamsToCanonicalV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
    >(
        &self,
        num_layers: O0,
        num_units: O1,
        input_size: O2,
        params: O3,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            num_layers.into(),
            num_units.into(),
            input_size.into(),
            params.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        num_layers: crate::Output,
        num_units: crate::Output,
        input_size: crate::Output,
        params: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("CudnnRNNParamsToCanonicalV2", |nd| {
            nd.add_input(num_layers);
            nd.add_input(num_units);
            nd.add_input(input_size);
            nd.add_input(params);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_params_weights {
                nd.set_attr_int("num_params_weights", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_params_biases {
                nd.set_attr_int("num_params_biases", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.rnn_mode {
                nd.set_attr_string("rnn_mode", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.input_mode {
                nd.set_attr_string("input_mode", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.direction {
                nd.set_attr_string("direction", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dropout {
                nd.set_attr_float("dropout", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed {
                nd.set_attr_int("seed", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed2 {
                nd.set_attr_int("seed2", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_proj {
                nd.set_attr_int("num_proj", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'CudnnRNNParamsToCanonicalV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        num_layers: crate::Output,
        num_units: crate::Output,
        input_size: crate::Output,
        params: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<CudnnRNNParamsToCanonicalV2Inst> {
        let op = scope.new_operation("CudnnRNNParamsToCanonicalV2", |builder| {
            builder.add_input(num_layers);
            builder.add_input(num_units);
            builder.add_input(input_size);
            builder.add_input(params);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_params_weights {
                builder.set_attr_int("num_params_weights", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_params_biases {
                builder.set_attr_int("num_params_biases", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.rnn_mode {
                builder.set_attr_string("rnn_mode", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.input_mode {
                builder.set_attr_string("input_mode", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.direction {
                builder.set_attr_string("direction", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dropout {
                builder.set_attr_float("dropout", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed {
                builder.set_attr_int("seed", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed2 {
                builder.set_attr_int("seed2", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_proj {
                builder.set_attr_int("num_proj", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(CudnnRNNParamsToCanonicalV2Inst { op })
    }
}
impl CudnnRNNParamsToCanonicalV2Inst {
    /// Returns a Vector of weights for 'weights' Output of this CudnnRNNParamsToCanonicalV2 operation.
    pub fn weights(&self) -> crate::Result<Vec<crate::Output>> {
        let mut Outputs = vec![];
        for i in 0..self.op.get_attr_int("num_params_weights")? as i32 {
            Outputs.push(crate::Output {
                operation: self.op.clone(),
                index: i,
            });
        }
        Ok(Outputs)
    }
    /// Returns a Vector of biases for 'biases' Output of this CudnnRNNParamsToCanonicalV2 operation.
    pub fn biases(&self) -> crate::Result<Vec<crate::Output>> {
        let dynamic_offset = (self.op.get_attr_int("num_params_weights")? + 1) as i32;
        let mut Outputs = vec![];
        for i in dynamic_offset..dynamic_offset + self.op.get_attr_int("num_params_biases")? as i32
        {
            Outputs.push(crate::Output {
                operation: self.op.clone(),
                index: i,
            });
        }
        Ok(Outputs)
    }
    /// Returns the 'num_layers' Input of this 'CudnnRNNParamsToCanonicalV2' operation.
    pub fn num_layers(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'num_units' Input of this 'CudnnRNNParamsToCanonicalV2' operation.
    pub fn num_units(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'input_size' Input of this 'CudnnRNNParamsToCanonicalV2' operation.
    pub fn input_size(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'params' Input of this 'CudnnRNNParamsToCanonicalV2' operation.
    pub fn params(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
}
impl From<CudnnRNNParamsToCanonicalV2Inst> for crate::Operation {
    fn from(inst: CudnnRNNParamsToCanonicalV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `CudnnRNNParamsToCanonicalV2::new().build(num_layers, num_units, input_size, params, scope)`.
pub fn cudnn_rnnparams_to_canonical_v2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
>(
    num_layers: O0,
    num_units: O1,
    input_size: O2,
    params: O3,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    CudnnRNNParamsToCanonicalV2::new().build(num_layers, num_units, input_size, params, scope)
}

/// Builder for the `CudnnRNNV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct CudnnRNNV2 {
    T: ::std::option::Option<crate::DataType>,
    rnn_mode: ::std::option::Option<::std::string::String>,
    input_mode: ::std::option::Option<::std::string::String>,
    direction: ::std::option::Option<::std::string::String>,
    dropout: ::std::option::Option<f32>,
    seed: ::std::option::Option<i64>,
    seed2: ::std::option::Option<i64>,
    is_training: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'CudnnRNNV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct CudnnRNNV2Inst {
    /// An instance of a fully built CudnnRNNV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl CudnnRNNV2 {
    /// Creates a new `CudnnRNNV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `rnn_mode` attribute.
    pub fn rnn_mode<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.rnn_mode = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `input_mode` attribute.
    pub fn input_mode<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.input_mode = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `direction` attribute.
    pub fn direction<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.direction = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `dropout` attribute.
    pub fn dropout<ArgType: ::std::convert::Into<f32>>(mut self, value: ArgType) -> Self {
        self.dropout = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `seed` attribute.
    pub fn seed<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.seed = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `seed2` attribute.
    pub fn seed2<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.seed2 = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `is_training` attribute.
    pub fn is_training<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.is_training = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `CudnnRNNV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        input_h: O1,
        input_c: O2,
        params: O3,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            input.into(),
            input_h.into(),
            input_c.into(),
            params.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        input: crate::Output,
        input_h: crate::Output,
        input_c: crate::Output,
        params: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("CudnnRNNV2", |nd| {
            nd.add_input(input);
            nd.add_input(input_h);
            nd.add_input(input_c);
            nd.add_input(params);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.rnn_mode {
                nd.set_attr_string("rnn_mode", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.input_mode {
                nd.set_attr_string("input_mode", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.direction {
                nd.set_attr_string("direction", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dropout {
                nd.set_attr_float("dropout", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed {
                nd.set_attr_int("seed", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed2 {
                nd.set_attr_int("seed2", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.is_training {
                nd.set_attr_bool("is_training", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'CudnnRNNV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        input_h: crate::Output,
        input_c: crate::Output,
        params: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<CudnnRNNV2Inst> {
        let op = scope.new_operation("CudnnRNNV2", |builder| {
            builder.add_input(input);
            builder.add_input(input_h);
            builder.add_input(input_c);
            builder.add_input(params);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.rnn_mode {
                builder.set_attr_string("rnn_mode", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.input_mode {
                builder.set_attr_string("input_mode", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.direction {
                builder.set_attr_string("direction", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dropout {
                builder.set_attr_float("dropout", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed {
                builder.set_attr_int("seed", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed2 {
                builder.set_attr_int("seed2", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.is_training {
                builder.set_attr_bool("is_training", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(CudnnRNNV2Inst { op })
    }
}
impl CudnnRNNV2Inst {
    /// Returns the 'output' Output of this 'CudnnRNNV2' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'output_h' Output of this 'CudnnRNNV2' operation.
    pub fn output_h(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'output_c' Output of this 'CudnnRNNV2' operation.
    pub fn output_c(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns the 'reserve_space' Output of this 'CudnnRNNV2' operation.
    pub fn reserve_space(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 3,
        }
    }
    /// Returns the 'host_reserved' Output of this 'CudnnRNNV2' operation.
    pub fn host_reserved(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 4,
        }
    }
    /// Returns the 'input' Input of this 'CudnnRNNV2' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'input_h' Input of this 'CudnnRNNV2' operation.
    pub fn input_h(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'input_c' Input of this 'CudnnRNNV2' operation.
    pub fn input_c(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'params' Input of this 'CudnnRNNV2' operation.
    pub fn params(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
}
impl From<CudnnRNNV2Inst> for crate::Operation {
    fn from(inst: CudnnRNNV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `CudnnRNNV2::new().build(input, input_h, input_c, params, scope)`.
pub fn cudnn_rnnv2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
>(
    input: O0,
    input_h: O1,
    input_c: O2,
    params: O3,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    CudnnRNNV2::new().build(input, input_h, input_c, params, scope)
}

/// Builder for the `CudnnRNNV3` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct CudnnRNNV3 {
    T: ::std::option::Option<crate::DataType>,
    rnn_mode: ::std::option::Option<::std::string::String>,
    input_mode: ::std::option::Option<::std::string::String>,
    direction: ::std::option::Option<::std::string::String>,
    dropout: ::std::option::Option<f32>,
    seed: ::std::option::Option<i64>,
    seed2: ::std::option::Option<i64>,
    num_proj: ::std::option::Option<i64>,
    is_training: ::std::option::Option<bool>,
    time_major: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'CudnnRNNV3' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct CudnnRNNV3Inst {
    /// An instance of a fully built CudnnRNNV3 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl CudnnRNNV3 {
    /// Creates a new `CudnnRNNV3`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `rnn_mode` attribute.
    pub fn rnn_mode<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.rnn_mode = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `input_mode` attribute.
    pub fn input_mode<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.input_mode = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `direction` attribute.
    pub fn direction<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.direction = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `dropout` attribute.
    pub fn dropout<ArgType: ::std::convert::Into<f32>>(mut self, value: ArgType) -> Self {
        self.dropout = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `seed` attribute.
    pub fn seed<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.seed = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `seed2` attribute.
    pub fn seed2<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.seed2 = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `num_proj` attribute.
    pub fn num_proj<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.num_proj = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `is_training` attribute.
    pub fn is_training<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.is_training = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `time_major` attribute.
    pub fn time_major<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.time_major = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `CudnnRNNV3` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        input_h: O1,
        input_c: O2,
        params: O3,
        sequence_lengths: O4,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            input.into(),
            input_h.into(),
            input_c.into(),
            params.into(),
            sequence_lengths.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        input: crate::Output,
        input_h: crate::Output,
        input_c: crate::Output,
        params: crate::Output,
        sequence_lengths: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("CudnnRNNV3", |nd| {
            nd.add_input(input);
            nd.add_input(input_h);
            nd.add_input(input_c);
            nd.add_input(params);
            nd.add_input(sequence_lengths);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.rnn_mode {
                nd.set_attr_string("rnn_mode", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.input_mode {
                nd.set_attr_string("input_mode", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.direction {
                nd.set_attr_string("direction", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dropout {
                nd.set_attr_float("dropout", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed {
                nd.set_attr_int("seed", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed2 {
                nd.set_attr_int("seed2", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_proj {
                nd.set_attr_int("num_proj", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.is_training {
                nd.set_attr_bool("is_training", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.time_major {
                nd.set_attr_bool("time_major", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'CudnnRNNV3' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        input_h: crate::Output,
        input_c: crate::Output,
        params: crate::Output,
        sequence_lengths: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<CudnnRNNV3Inst> {
        let op = scope.new_operation("CudnnRNNV3", |builder| {
            builder.add_input(input);
            builder.add_input(input_h);
            builder.add_input(input_c);
            builder.add_input(params);
            builder.add_input(sequence_lengths);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.rnn_mode {
                builder.set_attr_string("rnn_mode", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.input_mode {
                builder.set_attr_string("input_mode", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.direction {
                builder.set_attr_string("direction", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dropout {
                builder.set_attr_float("dropout", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed {
                builder.set_attr_int("seed", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed2 {
                builder.set_attr_int("seed2", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_proj {
                builder.set_attr_int("num_proj", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.is_training {
                builder.set_attr_bool("is_training", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.time_major {
                builder.set_attr_bool("time_major", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(CudnnRNNV3Inst { op })
    }
}
impl CudnnRNNV3Inst {
    /// Returns the 'output' Output of this 'CudnnRNNV3' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'output_h' Output of this 'CudnnRNNV3' operation.
    pub fn output_h(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'output_c' Output of this 'CudnnRNNV3' operation.
    pub fn output_c(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns the 'reserve_space' Output of this 'CudnnRNNV3' operation.
    pub fn reserve_space(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 3,
        }
    }
    /// Returns the 'host_reserved' Output of this 'CudnnRNNV3' operation.
    pub fn host_reserved(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 4,
        }
    }
    /// Returns the 'input' Input of this 'CudnnRNNV3' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'input_h' Input of this 'CudnnRNNV3' operation.
    pub fn input_h(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'input_c' Input of this 'CudnnRNNV3' operation.
    pub fn input_c(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'params' Input of this 'CudnnRNNV3' operation.
    pub fn params(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'sequence_lengths' Input of this 'CudnnRNNV3' operation.
    pub fn sequence_lengths(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
}
impl From<CudnnRNNV3Inst> for crate::Operation {
    fn from(inst: CudnnRNNV3Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `CudnnRNNV3::new().build(input, input_h, input_c, params, sequence_lengths, scope)`.
pub fn cudnn_rnnv3<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
>(
    input: O0,
    input_h: O1,
    input_c: O2,
    params: O3,
    sequence_lengths: O4,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    CudnnRNNV3::new().build(input, input_h, input_c, params, sequence_lengths, scope)
}

/// Builder for the `Cumprod` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Cumprod {
    exclusive: ::std::option::Option<bool>,
    reverse: ::std::option::Option<bool>,
    T: ::std::option::Option<crate::DataType>,
    Tidx: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Cumprod' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct CumprodInst {
    /// An instance of a fully built Cumprod Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Cumprod {
    /// Creates a new `Cumprod`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `exclusive` attribute.
    pub fn exclusive<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.exclusive = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `reverse` attribute.
    pub fn reverse<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.reverse = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tidx` attribute.
    pub fn Tidx<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Tidx = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Cumprod` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        x: O0,
        axis: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), axis.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        axis: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Cumprod", |nd| {
            nd.add_input(x);
            nd.add_input(axis);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.exclusive {
                nd.set_attr_bool("exclusive", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.reverse {
                nd.set_attr_bool("reverse", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tidx {
                nd.set_attr_type("Tidx", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Cumprod' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        axis: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<CumprodInst> {
        let op = scope.new_operation("Cumprod", |builder| {
            builder.add_input(x);
            builder.add_input(axis);
            if let ::std::option::Option::Some(value) = &self.exclusive {
                builder.set_attr_bool("exclusive", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.reverse {
                builder.set_attr_bool("reverse", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tidx {
                builder.set_attr_type("Tidx", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(CumprodInst { op })
    }
}
impl CumprodInst {
    /// Returns the 'out' Output of this 'Cumprod' operation.
    pub fn out(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'Cumprod' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'axis' Input of this 'Cumprod' operation.
    pub fn axis(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<CumprodInst> for crate::Operation {
    fn from(inst: CumprodInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Cumprod::new().build(x, axis, scope)`.
pub fn cumprod<O0: ::std::convert::Into<crate::Output>, O1: ::std::convert::Into<crate::Output>>(
    x: O0,
    axis: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Cumprod::new().build(x, axis, scope)
}

/// Builder for the `Cumsum` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Cumsum {
    exclusive: ::std::option::Option<bool>,
    reverse: ::std::option::Option<bool>,
    T: ::std::option::Option<crate::DataType>,
    Tidx: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Cumsum' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct CumsumInst {
    /// An instance of a fully built Cumsum Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Cumsum {
    /// Creates a new `Cumsum`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `exclusive` attribute.
    pub fn exclusive<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.exclusive = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `reverse` attribute.
    pub fn reverse<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.reverse = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tidx` attribute.
    pub fn Tidx<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Tidx = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Cumsum` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        x: O0,
        axis: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), axis.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        axis: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Cumsum", |nd| {
            nd.add_input(x);
            nd.add_input(axis);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.exclusive {
                nd.set_attr_bool("exclusive", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.reverse {
                nd.set_attr_bool("reverse", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tidx {
                nd.set_attr_type("Tidx", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Cumsum' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        axis: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<CumsumInst> {
        let op = scope.new_operation("Cumsum", |builder| {
            builder.add_input(x);
            builder.add_input(axis);
            if let ::std::option::Option::Some(value) = &self.exclusive {
                builder.set_attr_bool("exclusive", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.reverse {
                builder.set_attr_bool("reverse", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tidx {
                builder.set_attr_type("Tidx", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(CumsumInst { op })
    }
}
impl CumsumInst {
    /// Returns the 'out' Output of this 'Cumsum' operation.
    pub fn out(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'Cumsum' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'axis' Input of this 'Cumsum' operation.
    pub fn axis(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<CumsumInst> for crate::Operation {
    fn from(inst: CumsumInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Cumsum::new().build(x, axis, scope)`.
pub fn cumsum<O0: ::std::convert::Into<crate::Output>, O1: ::std::convert::Into<crate::Output>>(
    x: O0,
    axis: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Cumsum::new().build(x, axis, scope)
}

/// Builder for the `CumulativeLogsumexp` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct CumulativeLogsumexp {
    exclusive: ::std::option::Option<bool>,
    reverse: ::std::option::Option<bool>,
    T: ::std::option::Option<crate::DataType>,
    Tidx: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'CumulativeLogsumexp' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct CumulativeLogsumexpInst {
    /// An instance of a fully built CumulativeLogsumexp Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl CumulativeLogsumexp {
    /// Creates a new `CumulativeLogsumexp`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `exclusive` attribute.
    pub fn exclusive<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.exclusive = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `reverse` attribute.
    pub fn reverse<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.reverse = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tidx` attribute.
    pub fn Tidx<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Tidx = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `CumulativeLogsumexp` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        x: O0,
        axis: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), axis.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        axis: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("CumulativeLogsumexp", |nd| {
            nd.add_input(x);
            nd.add_input(axis);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.exclusive {
                nd.set_attr_bool("exclusive", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.reverse {
                nd.set_attr_bool("reverse", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tidx {
                nd.set_attr_type("Tidx", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'CumulativeLogsumexp' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        axis: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<CumulativeLogsumexpInst> {
        let op = scope.new_operation("CumulativeLogsumexp", |builder| {
            builder.add_input(x);
            builder.add_input(axis);
            if let ::std::option::Option::Some(value) = &self.exclusive {
                builder.set_attr_bool("exclusive", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.reverse {
                builder.set_attr_bool("reverse", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tidx {
                builder.set_attr_type("Tidx", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(CumulativeLogsumexpInst { op })
    }
}
impl CumulativeLogsumexpInst {
    /// Returns the 'out' Output of this 'CumulativeLogsumexp' operation.
    pub fn out(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'CumulativeLogsumexp' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'axis' Input of this 'CumulativeLogsumexp' operation.
    pub fn axis(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<CumulativeLogsumexpInst> for crate::Operation {
    fn from(inst: CumulativeLogsumexpInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `CumulativeLogsumexp::new().build(x, axis, scope)`.
pub fn cumulative_logsumexp<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    x: O0,
    axis: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    CumulativeLogsumexp::new().build(x, axis, scope)
}

/// Builder for the `DTensorRestoreV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct DTensorRestoreV2 {
    input_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    input_layouts: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
    dtypes: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'DTensorRestoreV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct DTensorRestoreV2Inst {
    /// An instance of a fully built DTensorRestoreV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl DTensorRestoreV2 {
    /// Creates a new `DTensorRestoreV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `input_shapes` attribute.
    pub fn input_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.input_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `input_layouts` attribute.
    pub fn input_layouts<ArgType: ::std::convert::Into<::std::vec::Vec<::std::string::String>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.input_layouts = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `dtypes` attribute.
    pub fn dtypes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.dtypes = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `DTensorRestoreV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        prefix: O0,
        tensor_names: O1,
        shape_and_slices: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            prefix.into(),
            tensor_names.into(),
            shape_and_slices.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        prefix: crate::Output,
        tensor_names: crate::Output,
        shape_and_slices: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("DTensorRestoreV2", |nd| {
            nd.add_input(prefix);
            nd.add_input(tensor_names);
            nd.add_input(shape_and_slices);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.input_shapes {
                nd.set_attr_shape_list("input_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.input_layouts {
                nd.set_attr_string_list("input_layouts", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dtypes {
                nd.set_attr_type_list("dtypes", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'DTensorRestoreV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        prefix: crate::Output,
        tensor_names: crate::Output,
        shape_and_slices: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<DTensorRestoreV2Inst> {
        let op = scope.new_operation("DTensorRestoreV2", |builder| {
            builder.add_input(prefix);
            builder.add_input(tensor_names);
            builder.add_input(shape_and_slices);
            if let ::std::option::Option::Some(value) = &self.input_shapes {
                builder.set_attr_shape_list("input_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.input_layouts {
                builder.set_attr_string_list("input_layouts", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dtypes {
                builder.set_attr_type_list("dtypes", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(DTensorRestoreV2Inst { op })
    }
}
impl DTensorRestoreV2Inst {
    /// Returns the 'tensors' Output of this 'DTensorRestoreV2' operation.
    pub fn tensors(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'prefix' Input of this 'DTensorRestoreV2' operation.
    pub fn prefix(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'tensor_names' Input of this 'DTensorRestoreV2' operation.
    pub fn tensor_names(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'shape_and_slices' Input of this 'DTensorRestoreV2' operation.
    pub fn shape_and_slices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<DTensorRestoreV2Inst> for crate::Operation {
    fn from(inst: DTensorRestoreV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `DTensorRestoreV2::new().build(prefix, tensor_names, shape_and_slices, scope)`.
pub fn dtensor_restore_v2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    prefix: O0,
    tensor_names: O1,
    shape_and_slices: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    DTensorRestoreV2::new().build(prefix, tensor_names, shape_and_slices, scope)
}

/// Builder for the `DTensorSetGlobalTPUArray` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct DTensorSetGlobalTPUArray {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'DTensorSetGlobalTPUArray' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct DTensorSetGlobalTPUArrayInst {
    /// An instance of a fully built DTensorSetGlobalTPUArray Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl DTensorSetGlobalTPUArray {
    /// Creates a new `DTensorSetGlobalTPUArray`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `DTensorSetGlobalTPUArray` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        topology: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(topology.into(), scope)
    }
    fn build_impl(
        &self,
        topology: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("DTensorSetGlobalTPUArray", |nd| {
            nd.add_input(topology);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'DTensorSetGlobalTPUArray' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        topology: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<DTensorSetGlobalTPUArrayInst> {
        let op = scope.new_operation("DTensorSetGlobalTPUArray", |builder| {
            builder.add_input(topology);
            ::std::result::Result::Ok(())
        })?;
        Ok(DTensorSetGlobalTPUArrayInst { op })
    }
}
impl DTensorSetGlobalTPUArrayInst {
    /// Returns the 'topology' Input of this 'DTensorSetGlobalTPUArray' operation.
    pub fn topology(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<DTensorSetGlobalTPUArrayInst> for crate::Operation {
    fn from(inst: DTensorSetGlobalTPUArrayInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `DTensorSetGlobalTPUArray::new().build(topology, scope)`.
pub fn dtensor_set_global_tpuarray<O0: ::std::convert::Into<crate::Output>>(
    topology: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    DTensorSetGlobalTPUArray::new().build(topology, scope)
}

/// Builder for the `DataFormatDimMap` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct DataFormatDimMap {
    T: ::std::option::Option<crate::DataType>,
    src_format: ::std::option::Option<::std::string::String>,
    dst_format: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'DataFormatDimMap' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct DataFormatDimMapInst {
    /// An instance of a fully built DataFormatDimMap Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl DataFormatDimMap {
    /// Creates a new `DataFormatDimMap`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `src_format` attribute.
    pub fn src_format<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.src_format = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `dst_format` attribute.
    pub fn dst_format<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.dst_format = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `DataFormatDimMap` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        x: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("DataFormatDimMap", |nd| {
            nd.add_input(x);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.src_format {
                nd.set_attr_string("src_format", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dst_format {
                nd.set_attr_string("dst_format", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'DataFormatDimMap' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<DataFormatDimMapInst> {
        let op = scope.new_operation("DataFormatDimMap", |builder| {
            builder.add_input(x);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.src_format {
                builder.set_attr_string("src_format", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dst_format {
                builder.set_attr_string("dst_format", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(DataFormatDimMapInst { op })
    }
}
impl DataFormatDimMapInst {
    /// Returns the 'y' Output of this 'DataFormatDimMap' operation.
    pub fn y(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'DataFormatDimMap' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<DataFormatDimMapInst> for crate::Operation {
    fn from(inst: DataFormatDimMapInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `DataFormatDimMap::new().build(x, scope)`.
pub fn data_format_dim_map<O0: ::std::convert::Into<crate::Output>>(
    x: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    DataFormatDimMap::new().build(x, scope)
}

/// Builder for the `DataFormatVecPermute` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct DataFormatVecPermute {
    T: ::std::option::Option<crate::DataType>,
    src_format: ::std::option::Option<::std::string::String>,
    dst_format: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'DataFormatVecPermute' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct DataFormatVecPermuteInst {
    /// An instance of a fully built DataFormatVecPermute Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl DataFormatVecPermute {
    /// Creates a new `DataFormatVecPermute`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `src_format` attribute.
    pub fn src_format<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.src_format = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `dst_format` attribute.
    pub fn dst_format<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.dst_format = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `DataFormatVecPermute` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        x: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("DataFormatVecPermute", |nd| {
            nd.add_input(x);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.src_format {
                nd.set_attr_string("src_format", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dst_format {
                nd.set_attr_string("dst_format", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'DataFormatVecPermute' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<DataFormatVecPermuteInst> {
        let op = scope.new_operation("DataFormatVecPermute", |builder| {
            builder.add_input(x);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.src_format {
                builder.set_attr_string("src_format", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dst_format {
                builder.set_attr_string("dst_format", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(DataFormatVecPermuteInst { op })
    }
}
impl DataFormatVecPermuteInst {
    /// Returns the 'y' Output of this 'DataFormatVecPermute' operation.
    pub fn y(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'DataFormatVecPermute' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<DataFormatVecPermuteInst> for crate::Operation {
    fn from(inst: DataFormatVecPermuteInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `DataFormatVecPermute::new().build(x, scope)`.
pub fn data_format_vec_permute<O0: ::std::convert::Into<crate::Output>>(
    x: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    DataFormatVecPermute::new().build(x, scope)
}

/// Builder for the `DataServiceDataset` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct DataServiceDataset {
    task_refresh_interval_hint_ms: ::std::option::Option<i64>,
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    data_transfer_protocol: ::std::option::Option<::std::string::String>,
    target_workers: ::std::option::Option<::std::string::String>,
    cross_trainer_cache_options: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'DataServiceDataset' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct DataServiceDatasetInst {
    /// An instance of a fully built DataServiceDataset Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl DataServiceDataset {
    /// Creates a new `DataServiceDataset`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `task_refresh_interval_hint_ms` attribute.
    pub fn task_refresh_interval_hint_ms<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.task_refresh_interval_hint_ms = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `data_transfer_protocol` attribute.
    pub fn data_transfer_protocol<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.data_transfer_protocol = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `target_workers` attribute.
    pub fn target_workers<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.target_workers = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `cross_trainer_cache_options` attribute.
    pub fn cross_trainer_cache_options<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.cross_trainer_cache_options = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `DataServiceDataset` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
        O6: ::std::convert::Into<crate::Output>,
    >(
        &self,
        dataset_id: O0,
        processing_mode: O1,
        address: O2,
        protocol: O3,
        job_name: O4,
        max_outstanding_requests: O5,
        iteration_counter: O6,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            dataset_id.into(),
            processing_mode.into(),
            address.into(),
            protocol.into(),
            job_name.into(),
            max_outstanding_requests.into(),
            iteration_counter.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        dataset_id: crate::Output,
        processing_mode: crate::Output,
        address: crate::Output,
        protocol: crate::Output,
        job_name: crate::Output,
        max_outstanding_requests: crate::Output,
        iteration_counter: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("DataServiceDataset", |nd| {
            nd.add_input(dataset_id);
            nd.add_input(processing_mode);
            nd.add_input(address);
            nd.add_input(protocol);
            nd.add_input(job_name);
            nd.add_input(max_outstanding_requests);
            nd.add_input(iteration_counter);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.task_refresh_interval_hint_ms {
                nd.set_attr_int("task_refresh_interval_hint_ms", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.data_transfer_protocol {
                nd.set_attr_string("data_transfer_protocol", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.target_workers {
                nd.set_attr_string("target_workers", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.cross_trainer_cache_options {
                nd.set_attr_string("cross_trainer_cache_options", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'DataServiceDataset' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        dataset_id: crate::Output,
        processing_mode: crate::Output,
        address: crate::Output,
        protocol: crate::Output,
        job_name: crate::Output,
        max_outstanding_requests: crate::Output,
        iteration_counter: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<DataServiceDatasetInst> {
        let op = scope.new_operation("DataServiceDataset", |builder| {
            builder.add_input(dataset_id);
            builder.add_input(processing_mode);
            builder.add_input(address);
            builder.add_input(protocol);
            builder.add_input(job_name);
            builder.add_input(max_outstanding_requests);
            builder.add_input(iteration_counter);
            if let ::std::option::Option::Some(value) = &self.task_refresh_interval_hint_ms {
                builder.set_attr_int("task_refresh_interval_hint_ms", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.data_transfer_protocol {
                builder.set_attr_string("data_transfer_protocol", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.target_workers {
                builder.set_attr_string("target_workers", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.cross_trainer_cache_options {
                builder.set_attr_string("cross_trainer_cache_options", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(DataServiceDatasetInst { op })
    }
}
impl DataServiceDatasetInst {
    /// Returns the 'handle' Output of this 'DataServiceDataset' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'dataset_id' Input of this 'DataServiceDataset' operation.
    pub fn dataset_id(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'processing_mode' Input of this 'DataServiceDataset' operation.
    pub fn processing_mode(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'address' Input of this 'DataServiceDataset' operation.
    pub fn address(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'protocol' Input of this 'DataServiceDataset' operation.
    pub fn protocol(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'job_name' Input of this 'DataServiceDataset' operation.
    pub fn job_name(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
    /// Returns the 'max_outstanding_requests' Input of this 'DataServiceDataset' operation.
    pub fn max_outstanding_requests(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 5,
        }
    }
    /// Returns the 'iteration_counter' Input of this 'DataServiceDataset' operation.
    pub fn iteration_counter(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 6,
        }
    }
}
impl From<DataServiceDatasetInst> for crate::Operation {
    fn from(inst: DataServiceDatasetInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `DataServiceDataset::new().build(dataset_id, processing_mode, address, protocol, job_name, max_outstanding_requests, iteration_counter, scope)`.
pub fn data_service_dataset<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
    O6: ::std::convert::Into<crate::Output>,
>(
    dataset_id: O0,
    processing_mode: O1,
    address: O2,
    protocol: O3,
    job_name: O4,
    max_outstanding_requests: O5,
    iteration_counter: O6,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    DataServiceDataset::new().build(
        dataset_id,
        processing_mode,
        address,
        protocol,
        job_name,
        max_outstanding_requests,
        iteration_counter,
        scope,
    )
}

/// Builder for the `DataServiceDatasetV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct DataServiceDatasetV2 {
    task_refresh_interval_hint_ms: ::std::option::Option<i64>,
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    data_transfer_protocol: ::std::option::Option<::std::string::String>,
    target_workers: ::std::option::Option<::std::string::String>,
    cross_trainer_cache_options: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'DataServiceDatasetV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct DataServiceDatasetV2Inst {
    /// An instance of a fully built DataServiceDatasetV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl DataServiceDatasetV2 {
    /// Creates a new `DataServiceDatasetV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `task_refresh_interval_hint_ms` attribute.
    pub fn task_refresh_interval_hint_ms<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.task_refresh_interval_hint_ms = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `data_transfer_protocol` attribute.
    pub fn data_transfer_protocol<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.data_transfer_protocol = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `target_workers` attribute.
    pub fn target_workers<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.target_workers = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `cross_trainer_cache_options` attribute.
    pub fn cross_trainer_cache_options<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.cross_trainer_cache_options = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `DataServiceDatasetV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
        O6: ::std::convert::Into<crate::Output>,
        O7: ::std::convert::Into<crate::Output>,
        O8: ::std::convert::Into<crate::Output>,
    >(
        &self,
        dataset_id: O0,
        processing_mode: O1,
        address: O2,
        protocol: O3,
        job_name: O4,
        consumer_index: O5,
        num_consumers: O6,
        max_outstanding_requests: O7,
        iteration_counter: O8,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            dataset_id.into(),
            processing_mode.into(),
            address.into(),
            protocol.into(),
            job_name.into(),
            consumer_index.into(),
            num_consumers.into(),
            max_outstanding_requests.into(),
            iteration_counter.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        dataset_id: crate::Output,
        processing_mode: crate::Output,
        address: crate::Output,
        protocol: crate::Output,
        job_name: crate::Output,
        consumer_index: crate::Output,
        num_consumers: crate::Output,
        max_outstanding_requests: crate::Output,
        iteration_counter: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("DataServiceDatasetV2", |nd| {
            nd.add_input(dataset_id);
            nd.add_input(processing_mode);
            nd.add_input(address);
            nd.add_input(protocol);
            nd.add_input(job_name);
            nd.add_input(consumer_index);
            nd.add_input(num_consumers);
            nd.add_input(max_outstanding_requests);
            nd.add_input(iteration_counter);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.task_refresh_interval_hint_ms {
                nd.set_attr_int("task_refresh_interval_hint_ms", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.data_transfer_protocol {
                nd.set_attr_string("data_transfer_protocol", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.target_workers {
                nd.set_attr_string("target_workers", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.cross_trainer_cache_options {
                nd.set_attr_string("cross_trainer_cache_options", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'DataServiceDatasetV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        dataset_id: crate::Output,
        processing_mode: crate::Output,
        address: crate::Output,
        protocol: crate::Output,
        job_name: crate::Output,
        consumer_index: crate::Output,
        num_consumers: crate::Output,
        max_outstanding_requests: crate::Output,
        iteration_counter: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<DataServiceDatasetV2Inst> {
        let op = scope.new_operation("DataServiceDatasetV2", |builder| {
            builder.add_input(dataset_id);
            builder.add_input(processing_mode);
            builder.add_input(address);
            builder.add_input(protocol);
            builder.add_input(job_name);
            builder.add_input(consumer_index);
            builder.add_input(num_consumers);
            builder.add_input(max_outstanding_requests);
            builder.add_input(iteration_counter);
            if let ::std::option::Option::Some(value) = &self.task_refresh_interval_hint_ms {
                builder.set_attr_int("task_refresh_interval_hint_ms", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.data_transfer_protocol {
                builder.set_attr_string("data_transfer_protocol", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.target_workers {
                builder.set_attr_string("target_workers", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.cross_trainer_cache_options {
                builder.set_attr_string("cross_trainer_cache_options", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(DataServiceDatasetV2Inst { op })
    }
}
impl DataServiceDatasetV2Inst {
    /// Returns the 'handle' Output of this 'DataServiceDatasetV2' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'dataset_id' Input of this 'DataServiceDatasetV2' operation.
    pub fn dataset_id(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'processing_mode' Input of this 'DataServiceDatasetV2' operation.
    pub fn processing_mode(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'address' Input of this 'DataServiceDatasetV2' operation.
    pub fn address(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'protocol' Input of this 'DataServiceDatasetV2' operation.
    pub fn protocol(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'job_name' Input of this 'DataServiceDatasetV2' operation.
    pub fn job_name(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
    /// Returns the 'consumer_index' Input of this 'DataServiceDatasetV2' operation.
    pub fn consumer_index(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 5,
        }
    }
    /// Returns the 'num_consumers' Input of this 'DataServiceDatasetV2' operation.
    pub fn num_consumers(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 6,
        }
    }
    /// Returns the 'max_outstanding_requests' Input of this 'DataServiceDatasetV2' operation.
    pub fn max_outstanding_requests(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 7,
        }
    }
    /// Returns the 'iteration_counter' Input of this 'DataServiceDatasetV2' operation.
    pub fn iteration_counter(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 8,
        }
    }
}
impl From<DataServiceDatasetV2Inst> for crate::Operation {
    fn from(inst: DataServiceDatasetV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `DataServiceDatasetV2::new().build(dataset_id, processing_mode, address, protocol, job_name, consumer_index, num_consumers, max_outstanding_requests, iteration_counter, scope)`.
pub fn data_service_dataset_v2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
    O6: ::std::convert::Into<crate::Output>,
    O7: ::std::convert::Into<crate::Output>,
    O8: ::std::convert::Into<crate::Output>,
>(
    dataset_id: O0,
    processing_mode: O1,
    address: O2,
    protocol: O3,
    job_name: O4,
    consumer_index: O5,
    num_consumers: O6,
    max_outstanding_requests: O7,
    iteration_counter: O8,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    DataServiceDatasetV2::new().build(
        dataset_id,
        processing_mode,
        address,
        protocol,
        job_name,
        consumer_index,
        num_consumers,
        max_outstanding_requests,
        iteration_counter,
        scope,
    )
}

/// Builder for the `DataServiceDatasetV3` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct DataServiceDatasetV3 {
    task_refresh_interval_hint_ms: ::std::option::Option<i64>,
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    data_transfer_protocol: ::std::option::Option<::std::string::String>,
    target_workers: ::std::option::Option<::std::string::String>,
    uncompress: ::std::option::Option<bool>,
    uncompress_fn: ::std::option::Option<::std::string::String>,
    cross_trainer_cache_options: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'DataServiceDatasetV3' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct DataServiceDatasetV3Inst {
    /// An instance of a fully built DataServiceDatasetV3 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl DataServiceDatasetV3 {
    /// Creates a new `DataServiceDatasetV3`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `task_refresh_interval_hint_ms` attribute.
    pub fn task_refresh_interval_hint_ms<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.task_refresh_interval_hint_ms = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `data_transfer_protocol` attribute.
    pub fn data_transfer_protocol<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.data_transfer_protocol = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `target_workers` attribute.
    pub fn target_workers<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.target_workers = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `uncompress` attribute.
    pub fn uncompress<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.uncompress = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `uncompress_fn` attribute.
    pub fn uncompress_fn<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.uncompress_fn = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `cross_trainer_cache_options` attribute.
    pub fn cross_trainer_cache_options<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.cross_trainer_cache_options = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `DataServiceDatasetV3` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
        O6: ::std::convert::Into<crate::Output>,
        O7: ::std::convert::Into<crate::Output>,
        O8: ::std::convert::Into<crate::Output>,
    >(
        &self,
        dataset_id: O0,
        processing_mode: O1,
        address: O2,
        protocol: O3,
        job_name: O4,
        consumer_index: O5,
        num_consumers: O6,
        max_outstanding_requests: O7,
        iteration_counter: O8,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            dataset_id.into(),
            processing_mode.into(),
            address.into(),
            protocol.into(),
            job_name.into(),
            consumer_index.into(),
            num_consumers.into(),
            max_outstanding_requests.into(),
            iteration_counter.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        dataset_id: crate::Output,
        processing_mode: crate::Output,
        address: crate::Output,
        protocol: crate::Output,
        job_name: crate::Output,
        consumer_index: crate::Output,
        num_consumers: crate::Output,
        max_outstanding_requests: crate::Output,
        iteration_counter: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("DataServiceDatasetV3", |nd| {
            nd.add_input(dataset_id);
            nd.add_input(processing_mode);
            nd.add_input(address);
            nd.add_input(protocol);
            nd.add_input(job_name);
            nd.add_input(consumer_index);
            nd.add_input(num_consumers);
            nd.add_input(max_outstanding_requests);
            nd.add_input(iteration_counter);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.task_refresh_interval_hint_ms {
                nd.set_attr_int("task_refresh_interval_hint_ms", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.data_transfer_protocol {
                nd.set_attr_string("data_transfer_protocol", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.target_workers {
                nd.set_attr_string("target_workers", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.uncompress {
                nd.set_attr_bool("uncompress", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.uncompress_fn {
                nd.set_attr_string("uncompress_fn", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.cross_trainer_cache_options {
                nd.set_attr_string("cross_trainer_cache_options", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'DataServiceDatasetV3' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        dataset_id: crate::Output,
        processing_mode: crate::Output,
        address: crate::Output,
        protocol: crate::Output,
        job_name: crate::Output,
        consumer_index: crate::Output,
        num_consumers: crate::Output,
        max_outstanding_requests: crate::Output,
        iteration_counter: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<DataServiceDatasetV3Inst> {
        let op = scope.new_operation("DataServiceDatasetV3", |builder| {
            builder.add_input(dataset_id);
            builder.add_input(processing_mode);
            builder.add_input(address);
            builder.add_input(protocol);
            builder.add_input(job_name);
            builder.add_input(consumer_index);
            builder.add_input(num_consumers);
            builder.add_input(max_outstanding_requests);
            builder.add_input(iteration_counter);
            if let ::std::option::Option::Some(value) = &self.task_refresh_interval_hint_ms {
                builder.set_attr_int("task_refresh_interval_hint_ms", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.data_transfer_protocol {
                builder.set_attr_string("data_transfer_protocol", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.target_workers {
                builder.set_attr_string("target_workers", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.uncompress {
                builder.set_attr_bool("uncompress", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.uncompress_fn {
                builder.set_attr_string("uncompress_fn", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.cross_trainer_cache_options {
                builder.set_attr_string("cross_trainer_cache_options", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(DataServiceDatasetV3Inst { op })
    }
}
impl DataServiceDatasetV3Inst {
    /// Returns the 'handle' Output of this 'DataServiceDatasetV3' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'dataset_id' Input of this 'DataServiceDatasetV3' operation.
    pub fn dataset_id(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'processing_mode' Input of this 'DataServiceDatasetV3' operation.
    pub fn processing_mode(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'address' Input of this 'DataServiceDatasetV3' operation.
    pub fn address(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'protocol' Input of this 'DataServiceDatasetV3' operation.
    pub fn protocol(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'job_name' Input of this 'DataServiceDatasetV3' operation.
    pub fn job_name(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
    /// Returns the 'consumer_index' Input of this 'DataServiceDatasetV3' operation.
    pub fn consumer_index(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 5,
        }
    }
    /// Returns the 'num_consumers' Input of this 'DataServiceDatasetV3' operation.
    pub fn num_consumers(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 6,
        }
    }
    /// Returns the 'max_outstanding_requests' Input of this 'DataServiceDatasetV3' operation.
    pub fn max_outstanding_requests(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 7,
        }
    }
    /// Returns the 'iteration_counter' Input of this 'DataServiceDatasetV3' operation.
    pub fn iteration_counter(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 8,
        }
    }
}
impl From<DataServiceDatasetV3Inst> for crate::Operation {
    fn from(inst: DataServiceDatasetV3Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `DataServiceDatasetV3::new().build(dataset_id, processing_mode, address, protocol, job_name, consumer_index, num_consumers, max_outstanding_requests, iteration_counter, scope)`.
pub fn data_service_dataset_v3<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
    O6: ::std::convert::Into<crate::Output>,
    O7: ::std::convert::Into<crate::Output>,
    O8: ::std::convert::Into<crate::Output>,
>(
    dataset_id: O0,
    processing_mode: O1,
    address: O2,
    protocol: O3,
    job_name: O4,
    consumer_index: O5,
    num_consumers: O6,
    max_outstanding_requests: O7,
    iteration_counter: O8,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    DataServiceDatasetV3::new().build(
        dataset_id,
        processing_mode,
        address,
        protocol,
        job_name,
        consumer_index,
        num_consumers,
        max_outstanding_requests,
        iteration_counter,
        scope,
    )
}

/// Builder for the `DataServiceDatasetV4` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct DataServiceDatasetV4 {
    task_refresh_interval_hint_ms: ::std::option::Option<i64>,
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    data_transfer_protocol: ::std::option::Option<::std::string::String>,
    target_workers: ::std::option::Option<::std::string::String>,
    uncompress: ::std::option::Option<bool>,
    uncompress_fn: ::std::option::Option<::std::string::String>,
    cross_trainer_cache_options: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'DataServiceDatasetV4' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct DataServiceDatasetV4Inst {
    /// An instance of a fully built DataServiceDatasetV4 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl DataServiceDatasetV4 {
    /// Creates a new `DataServiceDatasetV4`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `task_refresh_interval_hint_ms` attribute.
    pub fn task_refresh_interval_hint_ms<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.task_refresh_interval_hint_ms = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `data_transfer_protocol` attribute.
    pub fn data_transfer_protocol<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.data_transfer_protocol = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `target_workers` attribute.
    pub fn target_workers<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.target_workers = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `uncompress` attribute.
    pub fn uncompress<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.uncompress = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `uncompress_fn` attribute.
    pub fn uncompress_fn<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.uncompress_fn = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `cross_trainer_cache_options` attribute.
    pub fn cross_trainer_cache_options<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.cross_trainer_cache_options = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `DataServiceDatasetV4` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
        O6: ::std::convert::Into<crate::Output>,
        O7: ::std::convert::Into<crate::Output>,
        O8: ::std::convert::Into<crate::Output>,
    >(
        &self,
        dataset_id: O0,
        processing_mode: O1,
        address: O2,
        protocol: O3,
        job_name: O4,
        consumer_index: O5,
        num_consumers: O6,
        max_outstanding_requests: O7,
        iteration_counter: O8,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            dataset_id.into(),
            processing_mode.into(),
            address.into(),
            protocol.into(),
            job_name.into(),
            consumer_index.into(),
            num_consumers.into(),
            max_outstanding_requests.into(),
            iteration_counter.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        dataset_id: crate::Output,
        processing_mode: crate::Output,
        address: crate::Output,
        protocol: crate::Output,
        job_name: crate::Output,
        consumer_index: crate::Output,
        num_consumers: crate::Output,
        max_outstanding_requests: crate::Output,
        iteration_counter: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("DataServiceDatasetV4", |nd| {
            nd.add_input(dataset_id);
            nd.add_input(processing_mode);
            nd.add_input(address);
            nd.add_input(protocol);
            nd.add_input(job_name);
            nd.add_input(consumer_index);
            nd.add_input(num_consumers);
            nd.add_input(max_outstanding_requests);
            nd.add_input(iteration_counter);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.task_refresh_interval_hint_ms {
                nd.set_attr_int("task_refresh_interval_hint_ms", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.data_transfer_protocol {
                nd.set_attr_string("data_transfer_protocol", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.target_workers {
                nd.set_attr_string("target_workers", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.uncompress {
                nd.set_attr_bool("uncompress", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.uncompress_fn {
                nd.set_attr_string("uncompress_fn", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.cross_trainer_cache_options {
                nd.set_attr_string("cross_trainer_cache_options", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'DataServiceDatasetV4' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        dataset_id: crate::Output,
        processing_mode: crate::Output,
        address: crate::Output,
        protocol: crate::Output,
        job_name: crate::Output,
        consumer_index: crate::Output,
        num_consumers: crate::Output,
        max_outstanding_requests: crate::Output,
        iteration_counter: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<DataServiceDatasetV4Inst> {
        let op = scope.new_operation("DataServiceDatasetV4", |builder| {
            builder.add_input(dataset_id);
            builder.add_input(processing_mode);
            builder.add_input(address);
            builder.add_input(protocol);
            builder.add_input(job_name);
            builder.add_input(consumer_index);
            builder.add_input(num_consumers);
            builder.add_input(max_outstanding_requests);
            builder.add_input(iteration_counter);
            if let ::std::option::Option::Some(value) = &self.task_refresh_interval_hint_ms {
                builder.set_attr_int("task_refresh_interval_hint_ms", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.data_transfer_protocol {
                builder.set_attr_string("data_transfer_protocol", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.target_workers {
                builder.set_attr_string("target_workers", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.uncompress {
                builder.set_attr_bool("uncompress", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.uncompress_fn {
                builder.set_attr_string("uncompress_fn", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.cross_trainer_cache_options {
                builder.set_attr_string("cross_trainer_cache_options", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(DataServiceDatasetV4Inst { op })
    }
}
impl DataServiceDatasetV4Inst {
    /// Returns the 'handle' Output of this 'DataServiceDatasetV4' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'dataset_id' Input of this 'DataServiceDatasetV4' operation.
    pub fn dataset_id(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'processing_mode' Input of this 'DataServiceDatasetV4' operation.
    pub fn processing_mode(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'address' Input of this 'DataServiceDatasetV4' operation.
    pub fn address(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'protocol' Input of this 'DataServiceDatasetV4' operation.
    pub fn protocol(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'job_name' Input of this 'DataServiceDatasetV4' operation.
    pub fn job_name(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
    /// Returns the 'consumer_index' Input of this 'DataServiceDatasetV4' operation.
    pub fn consumer_index(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 5,
        }
    }
    /// Returns the 'num_consumers' Input of this 'DataServiceDatasetV4' operation.
    pub fn num_consumers(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 6,
        }
    }
    /// Returns the 'max_outstanding_requests' Input of this 'DataServiceDatasetV4' operation.
    pub fn max_outstanding_requests(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 7,
        }
    }
    /// Returns the 'iteration_counter' Input of this 'DataServiceDatasetV4' operation.
    pub fn iteration_counter(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 8,
        }
    }
}
impl From<DataServiceDatasetV4Inst> for crate::Operation {
    fn from(inst: DataServiceDatasetV4Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `DataServiceDatasetV4::new().build(dataset_id, processing_mode, address, protocol, job_name, consumer_index, num_consumers, max_outstanding_requests, iteration_counter, scope)`.
pub fn data_service_dataset_v4<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
    O6: ::std::convert::Into<crate::Output>,
    O7: ::std::convert::Into<crate::Output>,
    O8: ::std::convert::Into<crate::Output>,
>(
    dataset_id: O0,
    processing_mode: O1,
    address: O2,
    protocol: O3,
    job_name: O4,
    consumer_index: O5,
    num_consumers: O6,
    max_outstanding_requests: O7,
    iteration_counter: O8,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    DataServiceDatasetV4::new().build(
        dataset_id,
        processing_mode,
        address,
        protocol,
        job_name,
        consumer_index,
        num_consumers,
        max_outstanding_requests,
        iteration_counter,
        scope,
    )
}

/// Builder for the `DatasetCardinality` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct DatasetCardinality {
    cardinality_options: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'DatasetCardinality' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct DatasetCardinalityInst {
    /// An instance of a fully built DatasetCardinality Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl DatasetCardinality {
    /// Creates a new `DatasetCardinality`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `cardinality_options` attribute.
    pub fn cardinality_options<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.cardinality_options = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `DatasetCardinality` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input_dataset: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input_dataset.into(), scope)
    }
    fn build_impl(
        &self,
        input_dataset: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("DatasetCardinality", |nd| {
            nd.add_input(input_dataset);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.cardinality_options {
                nd.set_attr_string("cardinality_options", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'DatasetCardinality' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_dataset: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<DatasetCardinalityInst> {
        let op = scope.new_operation("DatasetCardinality", |builder| {
            builder.add_input(input_dataset);
            if let ::std::option::Option::Some(value) = &self.cardinality_options {
                builder.set_attr_string("cardinality_options", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(DatasetCardinalityInst { op })
    }
}
impl DatasetCardinalityInst {
    /// Returns the 'cardinality' Output of this 'DatasetCardinality' operation.
    pub fn cardinality(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_dataset' Input of this 'DatasetCardinality' operation.
    pub fn input_dataset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<DatasetCardinalityInst> for crate::Operation {
    fn from(inst: DatasetCardinalityInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `DatasetCardinality::new().build(input_dataset, scope)`.
pub fn dataset_cardinality<O0: ::std::convert::Into<crate::Output>>(
    input_dataset: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    DatasetCardinality::new().build(input_dataset, scope)
}

/// Builder for the `DatasetFromGraph` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct DatasetFromGraph {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'DatasetFromGraph' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct DatasetFromGraphInst {
    /// An instance of a fully built DatasetFromGraph Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl DatasetFromGraph {
    /// Creates a new `DatasetFromGraph`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `DatasetFromGraph` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        graph_def: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(graph_def.into(), scope)
    }
    fn build_impl(
        &self,
        graph_def: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("DatasetFromGraph", |nd| {
            nd.add_input(graph_def);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'DatasetFromGraph' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        graph_def: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<DatasetFromGraphInst> {
        let op = scope.new_operation("DatasetFromGraph", |builder| {
            builder.add_input(graph_def);
            ::std::result::Result::Ok(())
        })?;
        Ok(DatasetFromGraphInst { op })
    }
}
impl DatasetFromGraphInst {
    /// Returns the 'handle' Output of this 'DatasetFromGraph' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'graph_def' Input of this 'DatasetFromGraph' operation.
    pub fn graph_def(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<DatasetFromGraphInst> for crate::Operation {
    fn from(inst: DatasetFromGraphInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `DatasetFromGraph::new().build(graph_def, scope)`.
pub fn dataset_from_graph<O0: ::std::convert::Into<crate::Output>>(
    graph_def: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    DatasetFromGraph::new().build(graph_def, scope)
}

/// Builder for the `DatasetToGraph` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct DatasetToGraph {
    stateful_whitelist: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
    allow_stateful: ::std::option::Option<bool>,
    strip_device_assignment: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'DatasetToGraph' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct DatasetToGraphInst {
    /// An instance of a fully built DatasetToGraph Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl DatasetToGraph {
    /// Creates a new `DatasetToGraph`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `stateful_whitelist` attribute.
    pub fn stateful_whitelist<
        ArgType: ::std::convert::Into<::std::vec::Vec<::std::string::String>>,
    >(
        mut self,
        value: ArgType,
    ) -> Self {
        self.stateful_whitelist = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `allow_stateful` attribute.
    pub fn allow_stateful<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.allow_stateful = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `strip_device_assignment` attribute.
    pub fn strip_device_assignment<ArgType: ::std::convert::Into<bool>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.strip_device_assignment = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `DatasetToGraph` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input_dataset: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input_dataset.into(), scope)
    }
    fn build_impl(
        &self,
        input_dataset: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("DatasetToGraph", |nd| {
            nd.add_input(input_dataset);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.stateful_whitelist {
                nd.set_attr_string_list("stateful_whitelist", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.allow_stateful {
                nd.set_attr_bool("allow_stateful", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.strip_device_assignment {
                nd.set_attr_bool("strip_device_assignment", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'DatasetToGraph' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_dataset: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<DatasetToGraphInst> {
        let op = scope.new_operation("DatasetToGraph", |builder| {
            builder.add_input(input_dataset);
            if let ::std::option::Option::Some(value) = &self.stateful_whitelist {
                builder.set_attr_string_list("stateful_whitelist", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.allow_stateful {
                builder.set_attr_bool("allow_stateful", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.strip_device_assignment {
                builder.set_attr_bool("strip_device_assignment", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(DatasetToGraphInst { op })
    }
}
impl DatasetToGraphInst {
    /// Returns the 'graph' Output of this 'DatasetToGraph' operation.
    pub fn graph(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_dataset' Input of this 'DatasetToGraph' operation.
    pub fn input_dataset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<DatasetToGraphInst> for crate::Operation {
    fn from(inst: DatasetToGraphInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `DatasetToGraph::new().build(input_dataset, scope)`.
pub fn dataset_to_graph<O0: ::std::convert::Into<crate::Output>>(
    input_dataset: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    DatasetToGraph::new().build(input_dataset, scope)
}

/// Builder for the `DatasetToGraphV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct DatasetToGraphV2 {
    external_state_policy: ::std::option::Option<i64>,
    strip_device_assignment: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'DatasetToGraphV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct DatasetToGraphV2Inst {
    /// An instance of a fully built DatasetToGraphV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl DatasetToGraphV2 {
    /// Creates a new `DatasetToGraphV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `external_state_policy` attribute.
    pub fn external_state_policy<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.external_state_policy = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `strip_device_assignment` attribute.
    pub fn strip_device_assignment<ArgType: ::std::convert::Into<bool>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.strip_device_assignment = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `DatasetToGraphV2` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input_dataset: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input_dataset.into(), scope)
    }
    fn build_impl(
        &self,
        input_dataset: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("DatasetToGraphV2", |nd| {
            nd.add_input(input_dataset);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.external_state_policy {
                nd.set_attr_int("external_state_policy", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.strip_device_assignment {
                nd.set_attr_bool("strip_device_assignment", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'DatasetToGraphV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_dataset: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<DatasetToGraphV2Inst> {
        let op = scope.new_operation("DatasetToGraphV2", |builder| {
            builder.add_input(input_dataset);
            if let ::std::option::Option::Some(value) = &self.external_state_policy {
                builder.set_attr_int("external_state_policy", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.strip_device_assignment {
                builder.set_attr_bool("strip_device_assignment", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(DatasetToGraphV2Inst { op })
    }
}
impl DatasetToGraphV2Inst {
    /// Returns the 'graph' Output of this 'DatasetToGraphV2' operation.
    pub fn graph(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_dataset' Input of this 'DatasetToGraphV2' operation.
    pub fn input_dataset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<DatasetToGraphV2Inst> for crate::Operation {
    fn from(inst: DatasetToGraphV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `DatasetToGraphV2::new().build(input_dataset, scope)`.
pub fn dataset_to_graph_v2<O0: ::std::convert::Into<crate::Output>>(
    input_dataset: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    DatasetToGraphV2::new().build(input_dataset, scope)
}

/// Builder for the `DatasetToSingleElement` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct DatasetToSingleElement {
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    metadata: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'DatasetToSingleElement' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct DatasetToSingleElementInst {
    /// An instance of a fully built DatasetToSingleElement Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl DatasetToSingleElement {
    /// Creates a new `DatasetToSingleElement`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `metadata` attribute.
    pub fn metadata<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.metadata = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `DatasetToSingleElement` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        dataset: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(dataset.into(), scope)
    }
    fn build_impl(
        &self,
        dataset: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("DatasetToSingleElement", |nd| {
            nd.add_input(dataset);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.metadata {
                nd.set_attr_string("metadata", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'DatasetToSingleElement' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        dataset: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<DatasetToSingleElementInst> {
        let op = scope.new_operation("DatasetToSingleElement", |builder| {
            builder.add_input(dataset);
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.metadata {
                builder.set_attr_string("metadata", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(DatasetToSingleElementInst { op })
    }
}
impl DatasetToSingleElementInst {
    /// Returns the 'components' Output of this 'DatasetToSingleElement' operation.
    pub fn components(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'dataset' Input of this 'DatasetToSingleElement' operation.
    pub fn dataset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<DatasetToSingleElementInst> for crate::Operation {
    fn from(inst: DatasetToSingleElementInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `DatasetToSingleElement::new().build(dataset, scope)`.
pub fn dataset_to_single_element<O0: ::std::convert::Into<crate::Output>>(
    dataset: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    DatasetToSingleElement::new().build(dataset, scope)
}

/// Builder for the `DatasetToTFRecord` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct DatasetToTFRecord {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'DatasetToTFRecord' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct DatasetToTFRecordInst {
    /// An instance of a fully built DatasetToTFRecord Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl DatasetToTFRecord {
    /// Creates a new `DatasetToTFRecord`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `DatasetToTFRecord` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input_dataset: O0,
        filename: O1,
        compression_type: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            input_dataset.into(),
            filename.into(),
            compression_type.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        input_dataset: crate::Output,
        filename: crate::Output,
        compression_type: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("DatasetToTFRecord", |nd| {
            nd.add_input(input_dataset);
            nd.add_input(filename);
            nd.add_input(compression_type);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'DatasetToTFRecord' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_dataset: crate::Output,
        filename: crate::Output,
        compression_type: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<DatasetToTFRecordInst> {
        let op = scope.new_operation("DatasetToTFRecord", |builder| {
            builder.add_input(input_dataset);
            builder.add_input(filename);
            builder.add_input(compression_type);
            ::std::result::Result::Ok(())
        })?;
        Ok(DatasetToTFRecordInst { op })
    }
}
impl DatasetToTFRecordInst {
    /// Returns the 'input_dataset' Input of this 'DatasetToTFRecord' operation.
    pub fn input_dataset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'filename' Input of this 'DatasetToTFRecord' operation.
    pub fn filename(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'compression_type' Input of this 'DatasetToTFRecord' operation.
    pub fn compression_type(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<DatasetToTFRecordInst> for crate::Operation {
    fn from(inst: DatasetToTFRecordInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `DatasetToTFRecord::new().build(input_dataset, filename, compression_type, scope)`.
pub fn dataset_to_tfrecord<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    input_dataset: O0,
    filename: O1,
    compression_type: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    DatasetToTFRecord::new().build(input_dataset, filename, compression_type, scope)
}

/// Builder for the `Dawsn` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Dawsn {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Dawsn' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct DawsnInst {
    /// An instance of a fully built Dawsn Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Dawsn {
    /// Creates a new `Dawsn`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Dawsn` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        x: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Dawsn", |nd| {
            nd.add_input(x);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Dawsn' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<DawsnInst> {
        let op = scope.new_operation("Dawsn", |builder| {
            builder.add_input(x);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(DawsnInst { op })
    }
}
impl DawsnInst {
    /// Returns the 'y' Output of this 'Dawsn' operation.
    pub fn y(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'Dawsn' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<DawsnInst> for crate::Operation {
    fn from(inst: DawsnInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Dawsn::new().build(x, scope)`.
pub fn dawsn<O0: ::std::convert::Into<crate::Output>>(
    x: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Dawsn::new().build(x, scope)
}

/// Builder for the `DebugGradientIdentity` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct DebugGradientIdentity {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'DebugGradientIdentity' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct DebugGradientIdentityInst {
    /// An instance of a fully built DebugGradientIdentity Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl DebugGradientIdentity {
    /// Creates a new `DebugGradientIdentity`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `DebugGradientIdentity` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("DebugGradientIdentity", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'DebugGradientIdentity' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<DebugGradientIdentityInst> {
        let op = scope.new_operation("DebugGradientIdentity", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(DebugGradientIdentityInst { op })
    }
}
impl DebugGradientIdentityInst {
    /// Returns the 'output' Output of this 'DebugGradientIdentity' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'DebugGradientIdentity' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<DebugGradientIdentityInst> for crate::Operation {
    fn from(inst: DebugGradientIdentityInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `DebugGradientIdentity::new().build(input, scope)`.
pub fn debug_gradient_identity<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    DebugGradientIdentity::new().build(input, scope)
}

/// Builder for the `DebugGradientRefIdentity` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct DebugGradientRefIdentity {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'DebugGradientRefIdentity' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct DebugGradientRefIdentityInst {
    /// An instance of a fully built DebugGradientRefIdentity Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl DebugGradientRefIdentity {
    /// Creates a new `DebugGradientRefIdentity`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `DebugGradientRefIdentity` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("DebugGradientRefIdentity", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'DebugGradientRefIdentity' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<DebugGradientRefIdentityInst> {
        let op = scope.new_operation("DebugGradientRefIdentity", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(DebugGradientRefIdentityInst { op })
    }
}
impl DebugGradientRefIdentityInst {
    /// Returns the 'output' Output of this 'DebugGradientRefIdentity' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'DebugGradientRefIdentity' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<DebugGradientRefIdentityInst> for crate::Operation {
    fn from(inst: DebugGradientRefIdentityInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `DebugGradientRefIdentity::new().build(input, scope)`.
pub fn debug_gradient_ref_identity<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    DebugGradientRefIdentity::new().build(input, scope)
}

/// Builder for the `DebugIdentity` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct DebugIdentity {
    T: ::std::option::Option<crate::DataType>,
    device_name: ::std::option::Option<::std::string::String>,
    tensor_name: ::std::option::Option<::std::string::String>,
    debug_urls: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
    gated_grpc: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'DebugIdentity' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct DebugIdentityInst {
    /// An instance of a fully built DebugIdentity Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl DebugIdentity {
    /// Creates a new `DebugIdentity`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `device_name` attribute.
    pub fn device_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.device_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `tensor_name` attribute.
    pub fn tensor_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.tensor_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `debug_urls` attribute.
    pub fn debug_urls<ArgType: ::std::convert::Into<::std::vec::Vec<::std::string::String>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.debug_urls = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `gated_grpc` attribute.
    pub fn gated_grpc<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.gated_grpc = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `DebugIdentity` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("DebugIdentity", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.device_name {
                nd.set_attr_string("device_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.tensor_name {
                nd.set_attr_string("tensor_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.debug_urls {
                nd.set_attr_string_list("debug_urls", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.gated_grpc {
                nd.set_attr_bool("gated_grpc", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'DebugIdentity' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<DebugIdentityInst> {
        let op = scope.new_operation("DebugIdentity", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.device_name {
                builder.set_attr_string("device_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.tensor_name {
                builder.set_attr_string("tensor_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.debug_urls {
                builder.set_attr_string_list("debug_urls", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.gated_grpc {
                builder.set_attr_bool("gated_grpc", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(DebugIdentityInst { op })
    }
}
impl DebugIdentityInst {
    /// Returns the 'output' Output of this 'DebugIdentity' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'DebugIdentity' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<DebugIdentityInst> for crate::Operation {
    fn from(inst: DebugIdentityInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `DebugIdentity::new().build(input, scope)`.
pub fn debug_identity<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    DebugIdentity::new().build(input, scope)
}

/// Builder for the `DebugIdentityV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct DebugIdentityV2 {
    T: ::std::option::Option<crate::DataType>,
    tfdbg_context_id: ::std::option::Option<::std::string::String>,
    op_name: ::std::option::Option<::std::string::String>,
    output_slot: ::std::option::Option<i64>,
    tensor_debug_mode: ::std::option::Option<i64>,
    debug_urls: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
    circular_buffer_size: ::std::option::Option<i64>,
    tfdbg_run_id: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'DebugIdentityV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct DebugIdentityV2Inst {
    /// An instance of a fully built DebugIdentityV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl DebugIdentityV2 {
    /// Creates a new `DebugIdentityV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `tfdbg_context_id` attribute.
    pub fn tfdbg_context_id<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.tfdbg_context_id = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `op_name` attribute.
    pub fn op_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.op_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_slot` attribute.
    pub fn output_slot<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.output_slot = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `tensor_debug_mode` attribute.
    pub fn tensor_debug_mode<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.tensor_debug_mode = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `debug_urls` attribute.
    pub fn debug_urls<ArgType: ::std::convert::Into<::std::vec::Vec<::std::string::String>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.debug_urls = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `circular_buffer_size` attribute.
    pub fn circular_buffer_size<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.circular_buffer_size = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `tfdbg_run_id` attribute.
    pub fn tfdbg_run_id<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.tfdbg_run_id = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `DebugIdentityV2` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("DebugIdentityV2", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.tfdbg_context_id {
                nd.set_attr_string("tfdbg_context_id", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.op_name {
                nd.set_attr_string("op_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_slot {
                nd.set_attr_int("output_slot", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.tensor_debug_mode {
                nd.set_attr_int("tensor_debug_mode", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.debug_urls {
                nd.set_attr_string_list("debug_urls", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.circular_buffer_size {
                nd.set_attr_int("circular_buffer_size", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.tfdbg_run_id {
                nd.set_attr_string("tfdbg_run_id", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'DebugIdentityV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<DebugIdentityV2Inst> {
        let op = scope.new_operation("DebugIdentityV2", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.tfdbg_context_id {
                builder.set_attr_string("tfdbg_context_id", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.op_name {
                builder.set_attr_string("op_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_slot {
                builder.set_attr_int("output_slot", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.tensor_debug_mode {
                builder.set_attr_int("tensor_debug_mode", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.debug_urls {
                builder.set_attr_string_list("debug_urls", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.circular_buffer_size {
                builder.set_attr_int("circular_buffer_size", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.tfdbg_run_id {
                builder.set_attr_string("tfdbg_run_id", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(DebugIdentityV2Inst { op })
    }
}
impl DebugIdentityV2Inst {
    /// Returns the 'output' Output of this 'DebugIdentityV2' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'DebugIdentityV2' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<DebugIdentityV2Inst> for crate::Operation {
    fn from(inst: DebugIdentityV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `DebugIdentityV2::new().build(input, scope)`.
pub fn debug_identity_v2<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    DebugIdentityV2::new().build(input, scope)
}

/// Builder for the `DebugIdentityV3` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct DebugIdentityV3 {
    T: ::std::option::Option<crate::DataType>,
    device_name: ::std::option::Option<::std::string::String>,
    tensor_name: ::std::option::Option<::std::string::String>,
    io_of_node: ::std::option::Option<::std::string::String>,
    is_input: ::std::option::Option<bool>,
    io_index: ::std::option::Option<i64>,
    debug_urls: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
    gated_grpc: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'DebugIdentityV3' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct DebugIdentityV3Inst {
    /// An instance of a fully built DebugIdentityV3 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl DebugIdentityV3 {
    /// Creates a new `DebugIdentityV3`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `device_name` attribute.
    pub fn device_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.device_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `tensor_name` attribute.
    pub fn tensor_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.tensor_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `io_of_node` attribute.
    pub fn io_of_node<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.io_of_node = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `is_input` attribute.
    pub fn is_input<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.is_input = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `io_index` attribute.
    pub fn io_index<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.io_index = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `debug_urls` attribute.
    pub fn debug_urls<ArgType: ::std::convert::Into<::std::vec::Vec<::std::string::String>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.debug_urls = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `gated_grpc` attribute.
    pub fn gated_grpc<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.gated_grpc = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `DebugIdentityV3` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("DebugIdentityV3", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.device_name {
                nd.set_attr_string("device_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.tensor_name {
                nd.set_attr_string("tensor_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.io_of_node {
                nd.set_attr_string("io_of_node", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.is_input {
                nd.set_attr_bool("is_input", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.io_index {
                nd.set_attr_int("io_index", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.debug_urls {
                nd.set_attr_string_list("debug_urls", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.gated_grpc {
                nd.set_attr_bool("gated_grpc", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'DebugIdentityV3' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<DebugIdentityV3Inst> {
        let op = scope.new_operation("DebugIdentityV3", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.device_name {
                builder.set_attr_string("device_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.tensor_name {
                builder.set_attr_string("tensor_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.io_of_node {
                builder.set_attr_string("io_of_node", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.is_input {
                builder.set_attr_bool("is_input", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.io_index {
                builder.set_attr_int("io_index", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.debug_urls {
                builder.set_attr_string_list("debug_urls", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.gated_grpc {
                builder.set_attr_bool("gated_grpc", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(DebugIdentityV3Inst { op })
    }
}
impl DebugIdentityV3Inst {
    /// Returns the 'output' Output of this 'DebugIdentityV3' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'DebugIdentityV3' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<DebugIdentityV3Inst> for crate::Operation {
    fn from(inst: DebugIdentityV3Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `DebugIdentityV3::new().build(input, scope)`.
pub fn debug_identity_v3<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    DebugIdentityV3::new().build(input, scope)
}

/// Builder for the `DebugNanCount` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct DebugNanCount {
    T: ::std::option::Option<crate::DataType>,
    device_name: ::std::option::Option<::std::string::String>,
    tensor_name: ::std::option::Option<::std::string::String>,
    debug_urls: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
    gated_grpc: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'DebugNanCount' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct DebugNanCountInst {
    /// An instance of a fully built DebugNanCount Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl DebugNanCount {
    /// Creates a new `DebugNanCount`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `device_name` attribute.
    pub fn device_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.device_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `tensor_name` attribute.
    pub fn tensor_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.tensor_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `debug_urls` attribute.
    pub fn debug_urls<ArgType: ::std::convert::Into<::std::vec::Vec<::std::string::String>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.debug_urls = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `gated_grpc` attribute.
    pub fn gated_grpc<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.gated_grpc = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `DebugNanCount` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("DebugNanCount", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.device_name {
                nd.set_attr_string("device_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.tensor_name {
                nd.set_attr_string("tensor_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.debug_urls {
                nd.set_attr_string_list("debug_urls", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.gated_grpc {
                nd.set_attr_bool("gated_grpc", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'DebugNanCount' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<DebugNanCountInst> {
        let op = scope.new_operation("DebugNanCount", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.device_name {
                builder.set_attr_string("device_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.tensor_name {
                builder.set_attr_string("tensor_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.debug_urls {
                builder.set_attr_string_list("debug_urls", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.gated_grpc {
                builder.set_attr_bool("gated_grpc", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(DebugNanCountInst { op })
    }
}
impl DebugNanCountInst {
    /// Returns the 'output' Output of this 'DebugNanCount' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'DebugNanCount' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<DebugNanCountInst> for crate::Operation {
    fn from(inst: DebugNanCountInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `DebugNanCount::new().build(input, scope)`.
pub fn debug_nan_count<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    DebugNanCount::new().build(input, scope)
}

/// Builder for the `DebugNumericSummary` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct DebugNumericSummary {
    T: ::std::option::Option<crate::DataType>,
    device_name: ::std::option::Option<::std::string::String>,
    tensor_name: ::std::option::Option<::std::string::String>,
    debug_urls: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
    lower_bound: ::std::option::Option<f32>,
    upper_bound: ::std::option::Option<f32>,
    mute_if_healthy: ::std::option::Option<bool>,
    gated_grpc: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'DebugNumericSummary' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct DebugNumericSummaryInst {
    /// An instance of a fully built DebugNumericSummary Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl DebugNumericSummary {
    /// Creates a new `DebugNumericSummary`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `device_name` attribute.
    pub fn device_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.device_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `tensor_name` attribute.
    pub fn tensor_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.tensor_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `debug_urls` attribute.
    pub fn debug_urls<ArgType: ::std::convert::Into<::std::vec::Vec<::std::string::String>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.debug_urls = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `lower_bound` attribute.
    pub fn lower_bound<ArgType: ::std::convert::Into<f32>>(mut self, value: ArgType) -> Self {
        self.lower_bound = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `upper_bound` attribute.
    pub fn upper_bound<ArgType: ::std::convert::Into<f32>>(mut self, value: ArgType) -> Self {
        self.upper_bound = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `mute_if_healthy` attribute.
    pub fn mute_if_healthy<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.mute_if_healthy = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `gated_grpc` attribute.
    pub fn gated_grpc<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.gated_grpc = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `DebugNumericSummary` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("DebugNumericSummary", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.device_name {
                nd.set_attr_string("device_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.tensor_name {
                nd.set_attr_string("tensor_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.debug_urls {
                nd.set_attr_string_list("debug_urls", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.lower_bound {
                nd.set_attr_float("lower_bound", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.upper_bound {
                nd.set_attr_float("upper_bound", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.mute_if_healthy {
                nd.set_attr_bool("mute_if_healthy", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.gated_grpc {
                nd.set_attr_bool("gated_grpc", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'DebugNumericSummary' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<DebugNumericSummaryInst> {
        let op = scope.new_operation("DebugNumericSummary", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.device_name {
                builder.set_attr_string("device_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.tensor_name {
                builder.set_attr_string("tensor_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.debug_urls {
                builder.set_attr_string_list("debug_urls", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.lower_bound {
                builder.set_attr_float("lower_bound", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.upper_bound {
                builder.set_attr_float("upper_bound", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.mute_if_healthy {
                builder.set_attr_bool("mute_if_healthy", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.gated_grpc {
                builder.set_attr_bool("gated_grpc", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(DebugNumericSummaryInst { op })
    }
}
impl DebugNumericSummaryInst {
    /// Returns the 'output' Output of this 'DebugNumericSummary' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'DebugNumericSummary' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<DebugNumericSummaryInst> for crate::Operation {
    fn from(inst: DebugNumericSummaryInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `DebugNumericSummary::new().build(input, scope)`.
pub fn debug_numeric_summary<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    DebugNumericSummary::new().build(input, scope)
}

/// Builder for the `DebugNumericSummaryV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct DebugNumericSummaryV2 {
    output_dtype: ::std::option::Option<crate::DataType>,
    T: ::std::option::Option<crate::DataType>,
    tensor_debug_mode: ::std::option::Option<i64>,
    tensor_id: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'DebugNumericSummaryV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct DebugNumericSummaryV2Inst {
    /// An instance of a fully built DebugNumericSummaryV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl DebugNumericSummaryV2 {
    /// Creates a new `DebugNumericSummaryV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `output_dtype` attribute.
    pub fn output_dtype<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `tensor_debug_mode` attribute.
    pub fn tensor_debug_mode<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.tensor_debug_mode = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `tensor_id` attribute.
    pub fn tensor_id<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.tensor_id = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `DebugNumericSummaryV2` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("DebugNumericSummaryV2", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.output_dtype {
                nd.set_attr_type("output_dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.tensor_debug_mode {
                nd.set_attr_int("tensor_debug_mode", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.tensor_id {
                nd.set_attr_int("tensor_id", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'DebugNumericSummaryV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<DebugNumericSummaryV2Inst> {
        let op = scope.new_operation("DebugNumericSummaryV2", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.output_dtype {
                builder.set_attr_type("output_dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.tensor_debug_mode {
                builder.set_attr_int("tensor_debug_mode", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.tensor_id {
                builder.set_attr_int("tensor_id", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(DebugNumericSummaryV2Inst { op })
    }
}
impl DebugNumericSummaryV2Inst {
    /// Returns the 'output' Output of this 'DebugNumericSummaryV2' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'DebugNumericSummaryV2' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<DebugNumericSummaryV2Inst> for crate::Operation {
    fn from(inst: DebugNumericSummaryV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `DebugNumericSummaryV2::new().build(input, scope)`.
pub fn debug_numeric_summary_v2<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    DebugNumericSummaryV2::new().build(input, scope)
}

/// Builder for the `DecodeAndCropJpeg` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct DecodeAndCropJpeg {
    channels: ::std::option::Option<i64>,
    ratio: ::std::option::Option<i64>,
    fancy_upscaling: ::std::option::Option<bool>,
    try_recover_truncated: ::std::option::Option<bool>,
    acceptable_fraction: ::std::option::Option<f32>,
    dct_method: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'DecodeAndCropJpeg' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct DecodeAndCropJpegInst {
    /// An instance of a fully built DecodeAndCropJpeg Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl DecodeAndCropJpeg {
    /// Creates a new `DecodeAndCropJpeg`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `channels` attribute.
    pub fn channels<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.channels = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `ratio` attribute.
    pub fn ratio<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.ratio = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `fancy_upscaling` attribute.
    pub fn fancy_upscaling<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.fancy_upscaling = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `try_recover_truncated` attribute.
    pub fn try_recover_truncated<ArgType: ::std::convert::Into<bool>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.try_recover_truncated = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `acceptable_fraction` attribute.
    pub fn acceptable_fraction<ArgType: ::std::convert::Into<f32>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.acceptable_fraction = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `dct_method` attribute.
    pub fn dct_method<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.dct_method = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `DecodeAndCropJpeg` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        contents: O0,
        crop_window: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(contents.into(), crop_window.into(), scope)
    }
    fn build_impl(
        &self,
        contents: crate::Output,
        crop_window: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("DecodeAndCropJpeg", |nd| {
            nd.add_input(contents);
            nd.add_input(crop_window);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.channels {
                nd.set_attr_int("channels", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.ratio {
                nd.set_attr_int("ratio", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.fancy_upscaling {
                nd.set_attr_bool("fancy_upscaling", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.try_recover_truncated {
                nd.set_attr_bool("try_recover_truncated", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.acceptable_fraction {
                nd.set_attr_float("acceptable_fraction", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dct_method {
                nd.set_attr_string("dct_method", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'DecodeAndCropJpeg' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        contents: crate::Output,
        crop_window: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<DecodeAndCropJpegInst> {
        let op = scope.new_operation("DecodeAndCropJpeg", |builder| {
            builder.add_input(contents);
            builder.add_input(crop_window);
            if let ::std::option::Option::Some(value) = &self.channels {
                builder.set_attr_int("channels", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.ratio {
                builder.set_attr_int("ratio", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.fancy_upscaling {
                builder.set_attr_bool("fancy_upscaling", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.try_recover_truncated {
                builder.set_attr_bool("try_recover_truncated", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.acceptable_fraction {
                builder.set_attr_float("acceptable_fraction", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dct_method {
                builder.set_attr_string("dct_method", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(DecodeAndCropJpegInst { op })
    }
}
impl DecodeAndCropJpegInst {
    /// Returns the 'image' Output of this 'DecodeAndCropJpeg' operation.
    pub fn image(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'contents' Input of this 'DecodeAndCropJpeg' operation.
    pub fn contents(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'crop_window' Input of this 'DecodeAndCropJpeg' operation.
    pub fn crop_window(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<DecodeAndCropJpegInst> for crate::Operation {
    fn from(inst: DecodeAndCropJpegInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `DecodeAndCropJpeg::new().build(contents, crop_window, scope)`.
pub fn decode_and_crop_jpeg<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    contents: O0,
    crop_window: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    DecodeAndCropJpeg::new().build(contents, crop_window, scope)
}

/// Builder for the `DecodeBase64` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct DecodeBase64 {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'DecodeBase64' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct DecodeBase64Inst {
    /// An instance of a fully built DecodeBase64 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl DecodeBase64 {
    /// Creates a new `DecodeBase64`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `DecodeBase64` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("DecodeBase64", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'DecodeBase64' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<DecodeBase64Inst> {
        let op = scope.new_operation("DecodeBase64", |builder| {
            builder.add_input(input);
            ::std::result::Result::Ok(())
        })?;
        Ok(DecodeBase64Inst { op })
    }
}
impl DecodeBase64Inst {
    /// Returns the 'output' Output of this 'DecodeBase64' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'DecodeBase64' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<DecodeBase64Inst> for crate::Operation {
    fn from(inst: DecodeBase64Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `DecodeBase64::new().build(input, scope)`.
pub fn decode_base64<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    DecodeBase64::new().build(input, scope)
}

/// Builder for the `DecodeBmp` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct DecodeBmp {
    channels: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'DecodeBmp' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct DecodeBmpInst {
    /// An instance of a fully built DecodeBmp Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl DecodeBmp {
    /// Creates a new `DecodeBmp`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `channels` attribute.
    pub fn channels<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.channels = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `DecodeBmp` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        contents: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(contents.into(), scope)
    }
    fn build_impl(
        &self,
        contents: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("DecodeBmp", |nd| {
            nd.add_input(contents);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.channels {
                nd.set_attr_int("channels", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'DecodeBmp' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        contents: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<DecodeBmpInst> {
        let op = scope.new_operation("DecodeBmp", |builder| {
            builder.add_input(contents);
            if let ::std::option::Option::Some(value) = &self.channels {
                builder.set_attr_int("channels", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(DecodeBmpInst { op })
    }
}
impl DecodeBmpInst {
    /// Returns the 'image' Output of this 'DecodeBmp' operation.
    pub fn image(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'contents' Input of this 'DecodeBmp' operation.
    pub fn contents(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<DecodeBmpInst> for crate::Operation {
    fn from(inst: DecodeBmpInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `DecodeBmp::new().build(contents, scope)`.
pub fn decode_bmp<O0: ::std::convert::Into<crate::Output>>(
    contents: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    DecodeBmp::new().build(contents, scope)
}

/// Builder for the `DecodeCSV` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct DecodeCSV {
    OUT_TYPE: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    field_delim: ::std::option::Option<::std::string::String>,
    use_quote_delim: ::std::option::Option<bool>,
    na_value: ::std::option::Option<::std::string::String>,
    select_cols: ::std::option::Option<::std::vec::Vec<i64>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'DecodeCSV' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct DecodeCSVInst {
    /// An instance of a fully built DecodeCSV Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl DecodeCSV {
    /// Creates a new `DecodeCSV`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `OUT_TYPE` attribute.
    pub fn OUT_TYPE<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.OUT_TYPE = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `field_delim` attribute.
    pub fn field_delim<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.field_delim = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_quote_delim` attribute.
    pub fn use_quote_delim<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.use_quote_delim = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `na_value` attribute.
    pub fn na_value<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.na_value = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `select_cols` attribute.
    pub fn select_cols<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.select_cols = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `DecodeCSV` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        records: O0,
        record_defaults: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(records.into(), record_defaults.into(), scope)
    }
    fn build_impl(
        &self,
        records: crate::Output,
        record_defaults: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("DecodeCSV", |nd| {
            nd.add_input(records);
            nd.add_input(record_defaults);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.OUT_TYPE {
                nd.set_attr_type_list("OUT_TYPE", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.field_delim {
                nd.set_attr_string("field_delim", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_quote_delim {
                nd.set_attr_bool("use_quote_delim", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.na_value {
                nd.set_attr_string("na_value", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.select_cols {
                nd.set_attr_int_list("select_cols", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'DecodeCSV' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        records: crate::Output,
        record_defaults: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<DecodeCSVInst> {
        let op = scope.new_operation("DecodeCSV", |builder| {
            builder.add_input(records);
            builder.add_input(record_defaults);
            if let ::std::option::Option::Some(value) = &self.OUT_TYPE {
                builder.set_attr_type_list("OUT_TYPE", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.field_delim {
                builder.set_attr_string("field_delim", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_quote_delim {
                builder.set_attr_bool("use_quote_delim", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.na_value {
                builder.set_attr_string("na_value", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.select_cols {
                builder.set_attr_int_list("select_cols", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(DecodeCSVInst { op })
    }
}
impl DecodeCSVInst {
    /// Returns the 'output' Output of this 'DecodeCSV' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'records' Input of this 'DecodeCSV' operation.
    pub fn records(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'record_defaults' Input of this 'DecodeCSV' operation.
    pub fn record_defaults(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<DecodeCSVInst> for crate::Operation {
    fn from(inst: DecodeCSVInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `DecodeCSV::new().build(records, record_defaults, scope)`.
pub fn decode_csv<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    records: O0,
    record_defaults: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    DecodeCSV::new().build(records, record_defaults, scope)
}

/// Builder for the `DecodeCompressed` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct DecodeCompressed {
    compression_type: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'DecodeCompressed' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct DecodeCompressedInst {
    /// An instance of a fully built DecodeCompressed Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl DecodeCompressed {
    /// Creates a new `DecodeCompressed`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `compression_type` attribute.
    pub fn compression_type<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.compression_type = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `DecodeCompressed` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        bytes: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(bytes.into(), scope)
    }
    fn build_impl(
        &self,
        bytes: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("DecodeCompressed", |nd| {
            nd.add_input(bytes);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.compression_type {
                nd.set_attr_string("compression_type", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'DecodeCompressed' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        bytes: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<DecodeCompressedInst> {
        let op = scope.new_operation("DecodeCompressed", |builder| {
            builder.add_input(bytes);
            if let ::std::option::Option::Some(value) = &self.compression_type {
                builder.set_attr_string("compression_type", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(DecodeCompressedInst { op })
    }
}
impl DecodeCompressedInst {
    /// Returns the 'output' Output of this 'DecodeCompressed' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'bytes' Input of this 'DecodeCompressed' operation.
    pub fn bytes(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<DecodeCompressedInst> for crate::Operation {
    fn from(inst: DecodeCompressedInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `DecodeCompressed::new().build(bytes, scope)`.
pub fn decode_compressed<O0: ::std::convert::Into<crate::Output>>(
    bytes: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    DecodeCompressed::new().build(bytes, scope)
}

/// Builder for the `DecodeGif` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct DecodeGif {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'DecodeGif' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct DecodeGifInst {
    /// An instance of a fully built DecodeGif Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl DecodeGif {
    /// Creates a new `DecodeGif`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `DecodeGif` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        contents: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(contents.into(), scope)
    }
    fn build_impl(
        &self,
        contents: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("DecodeGif", |nd| {
            nd.add_input(contents);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'DecodeGif' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        contents: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<DecodeGifInst> {
        let op = scope.new_operation("DecodeGif", |builder| {
            builder.add_input(contents);
            ::std::result::Result::Ok(())
        })?;
        Ok(DecodeGifInst { op })
    }
}
impl DecodeGifInst {
    /// Returns the 'image' Output of this 'DecodeGif' operation.
    pub fn image(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'contents' Input of this 'DecodeGif' operation.
    pub fn contents(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<DecodeGifInst> for crate::Operation {
    fn from(inst: DecodeGifInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `DecodeGif::new().build(contents, scope)`.
pub fn decode_gif<O0: ::std::convert::Into<crate::Output>>(
    contents: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    DecodeGif::new().build(contents, scope)
}

/// Builder for the `DecodeImage` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct DecodeImage {
    channels: ::std::option::Option<i64>,
    dtype: ::std::option::Option<crate::DataType>,
    expand_animations: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'DecodeImage' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct DecodeImageInst {
    /// An instance of a fully built DecodeImage Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl DecodeImage {
    /// Creates a new `DecodeImage`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `channels` attribute.
    pub fn channels<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.channels = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `dtype` attribute.
    pub fn dtype<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `expand_animations` attribute.
    pub fn expand_animations<ArgType: ::std::convert::Into<bool>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.expand_animations = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `DecodeImage` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        contents: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(contents.into(), scope)
    }
    fn build_impl(
        &self,
        contents: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("DecodeImage", |nd| {
            nd.add_input(contents);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.channels {
                nd.set_attr_int("channels", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                nd.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.expand_animations {
                nd.set_attr_bool("expand_animations", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'DecodeImage' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        contents: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<DecodeImageInst> {
        let op = scope.new_operation("DecodeImage", |builder| {
            builder.add_input(contents);
            if let ::std::option::Option::Some(value) = &self.channels {
                builder.set_attr_int("channels", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                builder.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.expand_animations {
                builder.set_attr_bool("expand_animations", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(DecodeImageInst { op })
    }
}
impl DecodeImageInst {
    /// Returns the 'image' Output of this 'DecodeImage' operation.
    pub fn image(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'contents' Input of this 'DecodeImage' operation.
    pub fn contents(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<DecodeImageInst> for crate::Operation {
    fn from(inst: DecodeImageInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `DecodeImage::new().build(contents, scope)`.
pub fn decode_image<O0: ::std::convert::Into<crate::Output>>(
    contents: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    DecodeImage::new().build(contents, scope)
}

/// Builder for the `DecodeJSONExample` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct DecodeJSONExample {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'DecodeJSONExample' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct DecodeJSONExampleInst {
    /// An instance of a fully built DecodeJSONExample Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl DecodeJSONExample {
    /// Creates a new `DecodeJSONExample`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `DecodeJSONExample` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        json_examples: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(json_examples.into(), scope)
    }
    fn build_impl(
        &self,
        json_examples: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("DecodeJSONExample", |nd| {
            nd.add_input(json_examples);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'DecodeJSONExample' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        json_examples: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<DecodeJSONExampleInst> {
        let op = scope.new_operation("DecodeJSONExample", |builder| {
            builder.add_input(json_examples);
            ::std::result::Result::Ok(())
        })?;
        Ok(DecodeJSONExampleInst { op })
    }
}
impl DecodeJSONExampleInst {
    /// Returns the 'binary_examples' Output of this 'DecodeJSONExample' operation.
    pub fn binary_examples(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'json_examples' Input of this 'DecodeJSONExample' operation.
    pub fn json_examples(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<DecodeJSONExampleInst> for crate::Operation {
    fn from(inst: DecodeJSONExampleInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `DecodeJSONExample::new().build(json_examples, scope)`.
pub fn decode_jsonexample<O0: ::std::convert::Into<crate::Output>>(
    json_examples: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    DecodeJSONExample::new().build(json_examples, scope)
}

/// Builder for the `DecodeJpeg` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct DecodeJpeg {
    channels: ::std::option::Option<i64>,
    ratio: ::std::option::Option<i64>,
    fancy_upscaling: ::std::option::Option<bool>,
    try_recover_truncated: ::std::option::Option<bool>,
    acceptable_fraction: ::std::option::Option<f32>,
    dct_method: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'DecodeJpeg' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct DecodeJpegInst {
    /// An instance of a fully built DecodeJpeg Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl DecodeJpeg {
    /// Creates a new `DecodeJpeg`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `channels` attribute.
    pub fn channels<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.channels = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `ratio` attribute.
    pub fn ratio<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.ratio = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `fancy_upscaling` attribute.
    pub fn fancy_upscaling<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.fancy_upscaling = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `try_recover_truncated` attribute.
    pub fn try_recover_truncated<ArgType: ::std::convert::Into<bool>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.try_recover_truncated = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `acceptable_fraction` attribute.
    pub fn acceptable_fraction<ArgType: ::std::convert::Into<f32>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.acceptable_fraction = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `dct_method` attribute.
    pub fn dct_method<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.dct_method = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `DecodeJpeg` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        contents: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(contents.into(), scope)
    }
    fn build_impl(
        &self,
        contents: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("DecodeJpeg", |nd| {
            nd.add_input(contents);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.channels {
                nd.set_attr_int("channels", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.ratio {
                nd.set_attr_int("ratio", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.fancy_upscaling {
                nd.set_attr_bool("fancy_upscaling", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.try_recover_truncated {
                nd.set_attr_bool("try_recover_truncated", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.acceptable_fraction {
                nd.set_attr_float("acceptable_fraction", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dct_method {
                nd.set_attr_string("dct_method", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'DecodeJpeg' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        contents: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<DecodeJpegInst> {
        let op = scope.new_operation("DecodeJpeg", |builder| {
            builder.add_input(contents);
            if let ::std::option::Option::Some(value) = &self.channels {
                builder.set_attr_int("channels", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.ratio {
                builder.set_attr_int("ratio", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.fancy_upscaling {
                builder.set_attr_bool("fancy_upscaling", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.try_recover_truncated {
                builder.set_attr_bool("try_recover_truncated", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.acceptable_fraction {
                builder.set_attr_float("acceptable_fraction", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dct_method {
                builder.set_attr_string("dct_method", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(DecodeJpegInst { op })
    }
}
impl DecodeJpegInst {
    /// Returns the 'image' Output of this 'DecodeJpeg' operation.
    pub fn image(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'contents' Input of this 'DecodeJpeg' operation.
    pub fn contents(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<DecodeJpegInst> for crate::Operation {
    fn from(inst: DecodeJpegInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `DecodeJpeg::new().build(contents, scope)`.
pub fn decode_jpeg<O0: ::std::convert::Into<crate::Output>>(
    contents: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    DecodeJpeg::new().build(contents, scope)
}

/// Builder for the `DecodePaddedRaw` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct DecodePaddedRaw {
    out_type: ::std::option::Option<crate::DataType>,
    little_endian: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'DecodePaddedRaw' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct DecodePaddedRawInst {
    /// An instance of a fully built DecodePaddedRaw Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl DecodePaddedRaw {
    /// Creates a new `DecodePaddedRaw`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `out_type` attribute.
    pub fn out_type<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.out_type = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `little_endian` attribute.
    pub fn little_endian<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.little_endian = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `DecodePaddedRaw` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input_bytes: O0,
        fixed_length: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input_bytes.into(), fixed_length.into(), scope)
    }
    fn build_impl(
        &self,
        input_bytes: crate::Output,
        fixed_length: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("DecodePaddedRaw", |nd| {
            nd.add_input(input_bytes);
            nd.add_input(fixed_length);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.out_type {
                nd.set_attr_type("out_type", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.little_endian {
                nd.set_attr_bool("little_endian", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'DecodePaddedRaw' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_bytes: crate::Output,
        fixed_length: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<DecodePaddedRawInst> {
        let op = scope.new_operation("DecodePaddedRaw", |builder| {
            builder.add_input(input_bytes);
            builder.add_input(fixed_length);
            if let ::std::option::Option::Some(value) = &self.out_type {
                builder.set_attr_type("out_type", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.little_endian {
                builder.set_attr_bool("little_endian", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(DecodePaddedRawInst { op })
    }
}
impl DecodePaddedRawInst {
    /// Returns the 'output' Output of this 'DecodePaddedRaw' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_bytes' Input of this 'DecodePaddedRaw' operation.
    pub fn input_bytes(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'fixed_length' Input of this 'DecodePaddedRaw' operation.
    pub fn fixed_length(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<DecodePaddedRawInst> for crate::Operation {
    fn from(inst: DecodePaddedRawInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `DecodePaddedRaw::new().build(input_bytes, fixed_length, scope)`.
pub fn decode_padded_raw<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    input_bytes: O0,
    fixed_length: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    DecodePaddedRaw::new().build(input_bytes, fixed_length, scope)
}

/// Builder for the `DecodePng` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct DecodePng {
    channels: ::std::option::Option<i64>,
    dtype: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'DecodePng' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct DecodePngInst {
    /// An instance of a fully built DecodePng Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl DecodePng {
    /// Creates a new `DecodePng`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `channels` attribute.
    pub fn channels<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.channels = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `dtype` attribute.
    pub fn dtype<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `DecodePng` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        contents: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(contents.into(), scope)
    }
    fn build_impl(
        &self,
        contents: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("DecodePng", |nd| {
            nd.add_input(contents);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.channels {
                nd.set_attr_int("channels", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                nd.set_attr_type("dtype", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'DecodePng' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        contents: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<DecodePngInst> {
        let op = scope.new_operation("DecodePng", |builder| {
            builder.add_input(contents);
            if let ::std::option::Option::Some(value) = &self.channels {
                builder.set_attr_int("channels", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                builder.set_attr_type("dtype", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(DecodePngInst { op })
    }
}
impl DecodePngInst {
    /// Returns the 'image' Output of this 'DecodePng' operation.
    pub fn image(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'contents' Input of this 'DecodePng' operation.
    pub fn contents(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<DecodePngInst> for crate::Operation {
    fn from(inst: DecodePngInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `DecodePng::new().build(contents, scope)`.
pub fn decode_png<O0: ::std::convert::Into<crate::Output>>(
    contents: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    DecodePng::new().build(contents, scope)
}

/// Builder for the `DecodeProtoV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct DecodeProtoV2 {
    message_type: ::std::option::Option<::std::string::String>,
    field_names: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    descriptor_source: ::std::option::Option<::std::string::String>,
    message_format: ::std::option::Option<::std::string::String>,
    sanitize: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'DecodeProtoV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct DecodeProtoV2Inst {
    /// An instance of a fully built DecodeProtoV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl DecodeProtoV2 {
    /// Creates a new `DecodeProtoV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `message_type` attribute.
    pub fn message_type<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.message_type = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `field_names` attribute.
    pub fn field_names<ArgType: ::std::convert::Into<::std::vec::Vec<::std::string::String>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.field_names = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `descriptor_source` attribute.
    pub fn descriptor_source<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.descriptor_source = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `message_format` attribute.
    pub fn message_format<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.message_format = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `sanitize` attribute.
    pub fn sanitize<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.sanitize = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `DecodeProtoV2` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        bytes: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(bytes.into(), scope)
    }
    fn build_impl(
        &self,
        bytes: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("DecodeProtoV2", |nd| {
            nd.add_input(bytes);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.message_type {
                nd.set_attr_string("message_type", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.field_names {
                nd.set_attr_string_list("field_names", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.descriptor_source {
                nd.set_attr_string("descriptor_source", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.message_format {
                nd.set_attr_string("message_format", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.sanitize {
                nd.set_attr_bool("sanitize", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'DecodeProtoV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        bytes: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<DecodeProtoV2Inst> {
        let op = scope.new_operation("DecodeProtoV2", |builder| {
            builder.add_input(bytes);
            if let ::std::option::Option::Some(value) = &self.message_type {
                builder.set_attr_string("message_type", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.field_names {
                builder.set_attr_string_list("field_names", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.descriptor_source {
                builder.set_attr_string("descriptor_source", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.message_format {
                builder.set_attr_string("message_format", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.sanitize {
                builder.set_attr_bool("sanitize", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(DecodeProtoV2Inst { op })
    }
}
impl DecodeProtoV2Inst {
    /// Returns the 'sizes' Output of this 'DecodeProtoV2' operation.
    pub fn sizes(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'values' Output of this 'DecodeProtoV2' operation.
    pub fn values(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'bytes' Input of this 'DecodeProtoV2' operation.
    pub fn bytes(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<DecodeProtoV2Inst> for crate::Operation {
    fn from(inst: DecodeProtoV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `DecodeProtoV2::new().build(bytes, scope)`.
pub fn decode_proto_v2<O0: ::std::convert::Into<crate::Output>>(
    bytes: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    DecodeProtoV2::new().build(bytes, scope)
}

/// Builder for the `DecodeRaw` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct DecodeRaw {
    out_type: ::std::option::Option<crate::DataType>,
    little_endian: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'DecodeRaw' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct DecodeRawInst {
    /// An instance of a fully built DecodeRaw Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl DecodeRaw {
    /// Creates a new `DecodeRaw`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `out_type` attribute.
    pub fn out_type<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.out_type = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `little_endian` attribute.
    pub fn little_endian<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.little_endian = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `DecodeRaw` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        bytes: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(bytes.into(), scope)
    }
    fn build_impl(
        &self,
        bytes: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("DecodeRaw", |nd| {
            nd.add_input(bytes);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.out_type {
                nd.set_attr_type("out_type", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.little_endian {
                nd.set_attr_bool("little_endian", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'DecodeRaw' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        bytes: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<DecodeRawInst> {
        let op = scope.new_operation("DecodeRaw", |builder| {
            builder.add_input(bytes);
            if let ::std::option::Option::Some(value) = &self.out_type {
                builder.set_attr_type("out_type", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.little_endian {
                builder.set_attr_bool("little_endian", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(DecodeRawInst { op })
    }
}
impl DecodeRawInst {
    /// Returns the 'output' Output of this 'DecodeRaw' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'bytes' Input of this 'DecodeRaw' operation.
    pub fn bytes(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<DecodeRawInst> for crate::Operation {
    fn from(inst: DecodeRawInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `DecodeRaw::new().build(bytes, scope)`.
pub fn decode_raw<O0: ::std::convert::Into<crate::Output>>(
    bytes: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    DecodeRaw::new().build(bytes, scope)
}

/// Builder for the `DecodeWav` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct DecodeWav {
    desired_channels: ::std::option::Option<i64>,
    desired_samples: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'DecodeWav' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct DecodeWavInst {
    /// An instance of a fully built DecodeWav Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl DecodeWav {
    /// Creates a new `DecodeWav`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `desired_channels` attribute.
    pub fn desired_channels<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.desired_channels = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `desired_samples` attribute.
    pub fn desired_samples<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.desired_samples = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `DecodeWav` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        contents: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(contents.into(), scope)
    }
    fn build_impl(
        &self,
        contents: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("DecodeWav", |nd| {
            nd.add_input(contents);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.desired_channels {
                nd.set_attr_int("desired_channels", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.desired_samples {
                nd.set_attr_int("desired_samples", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'DecodeWav' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        contents: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<DecodeWavInst> {
        let op = scope.new_operation("DecodeWav", |builder| {
            builder.add_input(contents);
            if let ::std::option::Option::Some(value) = &self.desired_channels {
                builder.set_attr_int("desired_channels", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.desired_samples {
                builder.set_attr_int("desired_samples", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(DecodeWavInst { op })
    }
}
impl DecodeWavInst {
    /// Returns the 'audio' Output of this 'DecodeWav' operation.
    pub fn audio(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'sample_rate' Output of this 'DecodeWav' operation.
    pub fn sample_rate(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'contents' Input of this 'DecodeWav' operation.
    pub fn contents(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<DecodeWavInst> for crate::Operation {
    fn from(inst: DecodeWavInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `DecodeWav::new().build(contents, scope)`.
pub fn decode_wav<O0: ::std::convert::Into<crate::Output>>(
    contents: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    DecodeWav::new().build(contents, scope)
}

/// Builder for the `DeepCopy` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct DeepCopy {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'DeepCopy' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct DeepCopyInst {
    /// An instance of a fully built DeepCopy Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl DeepCopy {
    /// Creates a new `DeepCopy`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `DeepCopy` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        x: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("DeepCopy", |nd| {
            nd.add_input(x);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'DeepCopy' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<DeepCopyInst> {
        let op = scope.new_operation("DeepCopy", |builder| {
            builder.add_input(x);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(DeepCopyInst { op })
    }
}
impl DeepCopyInst {
    /// Returns the 'y' Output of this 'DeepCopy' operation.
    pub fn y(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'DeepCopy' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<DeepCopyInst> for crate::Operation {
    fn from(inst: DeepCopyInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `DeepCopy::new().build(x, scope)`.
pub fn deep_copy<O0: ::std::convert::Into<crate::Output>>(
    x: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    DeepCopy::new().build(x, scope)
}

/// Builder for the `DeleteIterator` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct DeleteIterator {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'DeleteIterator' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct DeleteIteratorInst {
    /// An instance of a fully built DeleteIterator Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl DeleteIterator {
    /// Creates a new `DeleteIterator`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `DeleteIterator` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        handle: O0,
        deleter: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(handle.into(), deleter.into(), scope)
    }
    fn build_impl(
        &self,
        handle: crate::Output,
        deleter: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("DeleteIterator", |nd| {
            nd.add_input(handle);
            nd.add_input(deleter);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'DeleteIterator' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        handle: crate::Output,
        deleter: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<DeleteIteratorInst> {
        let op = scope.new_operation("DeleteIterator", |builder| {
            builder.add_input(handle);
            builder.add_input(deleter);
            ::std::result::Result::Ok(())
        })?;
        Ok(DeleteIteratorInst { op })
    }
}
impl DeleteIteratorInst {
    /// Returns the 'handle' Input of this 'DeleteIterator' operation.
    pub fn handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'deleter' Input of this 'DeleteIterator' operation.
    pub fn deleter(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<DeleteIteratorInst> for crate::Operation {
    fn from(inst: DeleteIteratorInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `DeleteIterator::new().build(handle, deleter, scope)`.
pub fn delete_iterator<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    handle: O0,
    deleter: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    DeleteIterator::new().build(handle, deleter, scope)
}

/// Builder for the `DeleteMemoryCache` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct DeleteMemoryCache {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'DeleteMemoryCache' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct DeleteMemoryCacheInst {
    /// An instance of a fully built DeleteMemoryCache Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl DeleteMemoryCache {
    /// Creates a new `DeleteMemoryCache`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `DeleteMemoryCache` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        handle: O0,
        deleter: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(handle.into(), deleter.into(), scope)
    }
    fn build_impl(
        &self,
        handle: crate::Output,
        deleter: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("DeleteMemoryCache", |nd| {
            nd.add_input(handle);
            nd.add_input(deleter);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'DeleteMemoryCache' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        handle: crate::Output,
        deleter: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<DeleteMemoryCacheInst> {
        let op = scope.new_operation("DeleteMemoryCache", |builder| {
            builder.add_input(handle);
            builder.add_input(deleter);
            ::std::result::Result::Ok(())
        })?;
        Ok(DeleteMemoryCacheInst { op })
    }
}
impl DeleteMemoryCacheInst {
    /// Returns the 'handle' Input of this 'DeleteMemoryCache' operation.
    pub fn handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'deleter' Input of this 'DeleteMemoryCache' operation.
    pub fn deleter(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<DeleteMemoryCacheInst> for crate::Operation {
    fn from(inst: DeleteMemoryCacheInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `DeleteMemoryCache::new().build(handle, deleter, scope)`.
pub fn delete_memory_cache<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    handle: O0,
    deleter: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    DeleteMemoryCache::new().build(handle, deleter, scope)
}

/// Builder for the `DeleteMultiDeviceIterator` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct DeleteMultiDeviceIterator {
    N: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'DeleteMultiDeviceIterator' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct DeleteMultiDeviceIteratorInst {
    /// An instance of a fully built DeleteMultiDeviceIterator Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl DeleteMultiDeviceIterator {
    /// Creates a new `DeleteMultiDeviceIterator`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `N` attribute.
    pub fn N<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.N = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `DeleteMultiDeviceIterator` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        multi_device_iterator: O0,
        iterators: O1,
        deleter: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            multi_device_iterator.into(),
            iterators.into(),
            deleter.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        multi_device_iterator: crate::Output,
        iterators: crate::Output,
        deleter: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("DeleteMultiDeviceIterator", |nd| {
            nd.add_input(multi_device_iterator);
            nd.add_input(iterators);
            nd.add_input(deleter);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.N {
                nd.set_attr_int("N", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'DeleteMultiDeviceIterator' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        multi_device_iterator: crate::Output,
        iterators: Vec<crate::Output>,
        deleter: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<DeleteMultiDeviceIteratorInst> {
        let op = scope.new_operation("DeleteMultiDeviceIterator", |builder| {
            builder.add_input(multi_device_iterator);
            builder.add_input_list(&iterators);
            builder.add_input(deleter);
            builder.set_attr_int("N", iterators.clone().len() as i64)?;
            ::std::result::Result::Ok(())
        })?;
        Ok(DeleteMultiDeviceIteratorInst { op })
    }
}
impl DeleteMultiDeviceIteratorInst {
    /// Returns the 'multi_device_iterator' Input of this 'DeleteMultiDeviceIterator' operation.
    pub fn multi_device_iterator(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns a Vector of iterators for 'iterators' Input of this DeleteMultiDeviceIterator operation.
    pub fn iterators(&self) -> crate::Result<Vec<crate::Input>> {
        let mut Inputs = vec![];
        for i in 1..self.op.get_attr_int("N")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
    /// Returns the 'deleter' Input of this 'DeleteMultiDeviceIterator' operation.
    pub fn deleter(&self) -> crate::Result<crate::Input> {
        let dynamic_offset = (self.op.get_attr_int("N")? + 2) as i32;
        Ok(crate::Input {
            operation: &self.op,
            index: dynamic_offset,
        })
    }
}
impl From<DeleteMultiDeviceIteratorInst> for crate::Operation {
    fn from(inst: DeleteMultiDeviceIteratorInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `DeleteMultiDeviceIterator::new().build(multi_device_iterator, iterators, deleter, scope)`.
pub fn delete_multi_device_iterator<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    multi_device_iterator: O0,
    iterators: O1,
    deleter: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    DeleteMultiDeviceIterator::new().build(multi_device_iterator, iterators, deleter, scope)
}

/// Builder for the `DeleteRandomSeedGenerator` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct DeleteRandomSeedGenerator {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'DeleteRandomSeedGenerator' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct DeleteRandomSeedGeneratorInst {
    /// An instance of a fully built DeleteRandomSeedGenerator Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl DeleteRandomSeedGenerator {
    /// Creates a new `DeleteRandomSeedGenerator`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `DeleteRandomSeedGenerator` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        handle: O0,
        deleter: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(handle.into(), deleter.into(), scope)
    }
    fn build_impl(
        &self,
        handle: crate::Output,
        deleter: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("DeleteRandomSeedGenerator", |nd| {
            nd.add_input(handle);
            nd.add_input(deleter);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'DeleteRandomSeedGenerator' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        handle: crate::Output,
        deleter: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<DeleteRandomSeedGeneratorInst> {
        let op = scope.new_operation("DeleteRandomSeedGenerator", |builder| {
            builder.add_input(handle);
            builder.add_input(deleter);
            ::std::result::Result::Ok(())
        })?;
        Ok(DeleteRandomSeedGeneratorInst { op })
    }
}
impl DeleteRandomSeedGeneratorInst {
    /// Returns the 'handle' Input of this 'DeleteRandomSeedGenerator' operation.
    pub fn handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'deleter' Input of this 'DeleteRandomSeedGenerator' operation.
    pub fn deleter(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<DeleteRandomSeedGeneratorInst> for crate::Operation {
    fn from(inst: DeleteRandomSeedGeneratorInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `DeleteRandomSeedGenerator::new().build(handle, deleter, scope)`.
pub fn delete_random_seed_generator<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    handle: O0,
    deleter: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    DeleteRandomSeedGenerator::new().build(handle, deleter, scope)
}

/// Builder for the `DeleteSeedGenerator` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct DeleteSeedGenerator {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'DeleteSeedGenerator' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct DeleteSeedGeneratorInst {
    /// An instance of a fully built DeleteSeedGenerator Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl DeleteSeedGenerator {
    /// Creates a new `DeleteSeedGenerator`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `DeleteSeedGenerator` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        handle: O0,
        deleter: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(handle.into(), deleter.into(), scope)
    }
    fn build_impl(
        &self,
        handle: crate::Output,
        deleter: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("DeleteSeedGenerator", |nd| {
            nd.add_input(handle);
            nd.add_input(deleter);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'DeleteSeedGenerator' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        handle: crate::Output,
        deleter: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<DeleteSeedGeneratorInst> {
        let op = scope.new_operation("DeleteSeedGenerator", |builder| {
            builder.add_input(handle);
            builder.add_input(deleter);
            ::std::result::Result::Ok(())
        })?;
        Ok(DeleteSeedGeneratorInst { op })
    }
}
impl DeleteSeedGeneratorInst {
    /// Returns the 'handle' Input of this 'DeleteSeedGenerator' operation.
    pub fn handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'deleter' Input of this 'DeleteSeedGenerator' operation.
    pub fn deleter(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<DeleteSeedGeneratorInst> for crate::Operation {
    fn from(inst: DeleteSeedGeneratorInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `DeleteSeedGenerator::new().build(handle, deleter, scope)`.
pub fn delete_seed_generator<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    handle: O0,
    deleter: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    DeleteSeedGenerator::new().build(handle, deleter, scope)
}

/// Builder for the `DeleteSessionTensor` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct DeleteSessionTensor {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'DeleteSessionTensor' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct DeleteSessionTensorInst {
    /// An instance of a fully built DeleteSessionTensor Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl DeleteSessionTensor {
    /// Creates a new `DeleteSessionTensor`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `DeleteSessionTensor` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        handle: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(handle.into(), scope)
    }
    fn build_impl(
        &self,
        handle: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("DeleteSessionTensor", |nd| {
            nd.add_input(handle);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'DeleteSessionTensor' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        handle: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<DeleteSessionTensorInst> {
        let op = scope.new_operation("DeleteSessionTensor", |builder| {
            builder.add_input(handle);
            ::std::result::Result::Ok(())
        })?;
        Ok(DeleteSessionTensorInst { op })
    }
}
impl DeleteSessionTensorInst {
    /// Returns the 'handle' Input of this 'DeleteSessionTensor' operation.
    pub fn handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<DeleteSessionTensorInst> for crate::Operation {
    fn from(inst: DeleteSessionTensorInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `DeleteSessionTensor::new().build(handle, scope)`.
pub fn delete_session_tensor<O0: ::std::convert::Into<crate::Output>>(
    handle: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    DeleteSessionTensor::new().build(handle, scope)
}

/// Builder for the `DenseBincount` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct DenseBincount {
    Tidx: ::std::option::Option<crate::DataType>,
    T: ::std::option::Option<crate::DataType>,
    binary_output: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'DenseBincount' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct DenseBincountInst {
    /// An instance of a fully built DenseBincount Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl DenseBincount {
    /// Creates a new `DenseBincount`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `Tidx` attribute.
    pub fn Tidx<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Tidx = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `binary_output` attribute.
    pub fn binary_output<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.binary_output = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `DenseBincount` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        size: O1,
        weights: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), size.into(), weights.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        size: crate::Output,
        weights: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("DenseBincount", |nd| {
            nd.add_input(input);
            nd.add_input(size);
            nd.add_input(weights);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.Tidx {
                nd.set_attr_type("Tidx", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.binary_output {
                nd.set_attr_bool("binary_output", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'DenseBincount' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        size: crate::Output,
        weights: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<DenseBincountInst> {
        let op = scope.new_operation("DenseBincount", |builder| {
            builder.add_input(input);
            builder.add_input(size);
            builder.add_input(weights);
            if let ::std::option::Option::Some(value) = &self.Tidx {
                builder.set_attr_type("Tidx", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.binary_output {
                builder.set_attr_bool("binary_output", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(DenseBincountInst { op })
    }
}
impl DenseBincountInst {
    /// Returns the 'output' Output of this 'DenseBincount' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'DenseBincount' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'size' Input of this 'DenseBincount' operation.
    pub fn size(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'weights' Input of this 'DenseBincount' operation.
    pub fn weights(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<DenseBincountInst> for crate::Operation {
    fn from(inst: DenseBincountInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `DenseBincount::new().build(input, size, weights, scope)`.
pub fn dense_bincount<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    input: O0,
    size: O1,
    weights: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    DenseBincount::new().build(input, size, weights, scope)
}

/// Builder for the `DenseCountSparseOutput` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct DenseCountSparseOutput {
    T: ::std::option::Option<crate::DataType>,
    minlength: ::std::option::Option<i64>,
    maxlength: ::std::option::Option<i64>,
    binary_output: ::std::option::Option<bool>,
    output_type: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'DenseCountSparseOutput' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct DenseCountSparseOutputInst {
    /// An instance of a fully built DenseCountSparseOutput Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl DenseCountSparseOutput {
    /// Creates a new `DenseCountSparseOutput`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `minlength` attribute.
    pub fn minlength<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.minlength = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `maxlength` attribute.
    pub fn maxlength<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.maxlength = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `binary_output` attribute.
    pub fn binary_output<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.binary_output = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_type` attribute.
    pub fn output_type<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_type = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `DenseCountSparseOutput` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        values: O0,
        weights: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(values.into(), weights.into(), scope)
    }
    fn build_impl(
        &self,
        values: crate::Output,
        weights: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("DenseCountSparseOutput", |nd| {
            nd.add_input(values);
            nd.add_input(weights);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.minlength {
                nd.set_attr_int("minlength", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.maxlength {
                nd.set_attr_int("maxlength", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.binary_output {
                nd.set_attr_bool("binary_output", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_type {
                nd.set_attr_type("output_type", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'DenseCountSparseOutput' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        values: crate::Output,
        weights: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<DenseCountSparseOutputInst> {
        let op = scope.new_operation("DenseCountSparseOutput", |builder| {
            builder.add_input(values);
            builder.add_input(weights);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.minlength {
                builder.set_attr_int("minlength", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.maxlength {
                builder.set_attr_int("maxlength", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.binary_output {
                builder.set_attr_bool("binary_output", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_type {
                builder.set_attr_type("output_type", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(DenseCountSparseOutputInst { op })
    }
}
impl DenseCountSparseOutputInst {
    /// Returns the 'output_indices' Output of this 'DenseCountSparseOutput' operation.
    pub fn output_indices(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'output_values' Output of this 'DenseCountSparseOutput' operation.
    pub fn output_values(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'output_dense_shape' Output of this 'DenseCountSparseOutput' operation.
    pub fn output_dense_shape(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns the 'values' Input of this 'DenseCountSparseOutput' operation.
    pub fn values(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'weights' Input of this 'DenseCountSparseOutput' operation.
    pub fn weights(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<DenseCountSparseOutputInst> for crate::Operation {
    fn from(inst: DenseCountSparseOutputInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `DenseCountSparseOutput::new().build(values, weights, scope)`.
pub fn dense_count_sparse_output<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    values: O0,
    weights: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    DenseCountSparseOutput::new().build(values, weights, scope)
}

/// Builder for the `DenseToCSRSparseMatrix` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct DenseToCSRSparseMatrix {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'DenseToCSRSparseMatrix' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct DenseToCSRSparseMatrixInst {
    /// An instance of a fully built DenseToCSRSparseMatrix Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl DenseToCSRSparseMatrix {
    /// Creates a new `DenseToCSRSparseMatrix`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `DenseToCSRSparseMatrix` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        dense_input: O0,
        indices: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(dense_input.into(), indices.into(), scope)
    }
    fn build_impl(
        &self,
        dense_input: crate::Output,
        indices: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("DenseToCSRSparseMatrix", |nd| {
            nd.add_input(dense_input);
            nd.add_input(indices);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'DenseToCSRSparseMatrix' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        dense_input: crate::Output,
        indices: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<DenseToCSRSparseMatrixInst> {
        let op = scope.new_operation("DenseToCSRSparseMatrix", |builder| {
            builder.add_input(dense_input);
            builder.add_input(indices);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(DenseToCSRSparseMatrixInst { op })
    }
}
impl DenseToCSRSparseMatrixInst {
    /// Returns the 'sparse_output' Output of this 'DenseToCSRSparseMatrix' operation.
    pub fn sparse_output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'dense_input' Input of this 'DenseToCSRSparseMatrix' operation.
    pub fn dense_input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'indices' Input of this 'DenseToCSRSparseMatrix' operation.
    pub fn indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<DenseToCSRSparseMatrixInst> for crate::Operation {
    fn from(inst: DenseToCSRSparseMatrixInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `DenseToCSRSparseMatrix::new().build(dense_input, indices, scope)`.
pub fn dense_to_csrsparse_matrix<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    dense_input: O0,
    indices: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    DenseToCSRSparseMatrix::new().build(dense_input, indices, scope)
}

/// Builder for the `DenseToDenseSetOperation` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct DenseToDenseSetOperation {
    set_operation: ::std::option::Option<::std::string::String>,
    validate_indices: ::std::option::Option<bool>,
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'DenseToDenseSetOperation' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct DenseToDenseSetOperationInst {
    /// An instance of a fully built DenseToDenseSetOperation Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl DenseToDenseSetOperation {
    /// Creates a new `DenseToDenseSetOperation`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `set_operation` attribute.
    pub fn set_operation<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.set_operation = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `validate_indices` attribute.
    pub fn validate_indices<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.validate_indices = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `DenseToDenseSetOperation` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        set1: O0,
        set2: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(set1.into(), set2.into(), scope)
    }
    fn build_impl(
        &self,
        set1: crate::Output,
        set2: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("DenseToDenseSetOperation", |nd| {
            nd.add_input(set1);
            nd.add_input(set2);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.set_operation {
                nd.set_attr_string("set_operation", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.validate_indices {
                nd.set_attr_bool("validate_indices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'DenseToDenseSetOperation' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        set1: crate::Output,
        set2: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<DenseToDenseSetOperationInst> {
        let op = scope.new_operation("DenseToDenseSetOperation", |builder| {
            builder.add_input(set1);
            builder.add_input(set2);
            if let ::std::option::Option::Some(value) = &self.set_operation {
                builder.set_attr_string("set_operation", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.validate_indices {
                builder.set_attr_bool("validate_indices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(DenseToDenseSetOperationInst { op })
    }
}
impl DenseToDenseSetOperationInst {
    /// Returns the 'result_indices' Output of this 'DenseToDenseSetOperation' operation.
    pub fn result_indices(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'result_values' Output of this 'DenseToDenseSetOperation' operation.
    pub fn result_values(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'result_shape' Output of this 'DenseToDenseSetOperation' operation.
    pub fn result_shape(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns the 'set1' Input of this 'DenseToDenseSetOperation' operation.
    pub fn set1(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'set2' Input of this 'DenseToDenseSetOperation' operation.
    pub fn set2(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<DenseToDenseSetOperationInst> for crate::Operation {
    fn from(inst: DenseToDenseSetOperationInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `DenseToDenseSetOperation::new().build(set1, set2, scope)`.
pub fn dense_to_dense_set_operation<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    set1: O0,
    set2: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    DenseToDenseSetOperation::new().build(set1, set2, scope)
}

/// Builder for the `DenseToSparseBatchDataset` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct DenseToSparseBatchDataset {
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'DenseToSparseBatchDataset' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct DenseToSparseBatchDatasetInst {
    /// An instance of a fully built DenseToSparseBatchDataset Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl DenseToSparseBatchDataset {
    /// Creates a new `DenseToSparseBatchDataset`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `DenseToSparseBatchDataset` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input_dataset: O0,
        batch_size: O1,
        row_shape: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            input_dataset.into(),
            batch_size.into(),
            row_shape.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        input_dataset: crate::Output,
        batch_size: crate::Output,
        row_shape: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("DenseToSparseBatchDataset", |nd| {
            nd.add_input(input_dataset);
            nd.add_input(batch_size);
            nd.add_input(row_shape);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'DenseToSparseBatchDataset' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_dataset: crate::Output,
        batch_size: crate::Output,
        row_shape: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<DenseToSparseBatchDatasetInst> {
        let op = scope.new_operation("DenseToSparseBatchDataset", |builder| {
            builder.add_input(input_dataset);
            builder.add_input(batch_size);
            builder.add_input(row_shape);
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(DenseToSparseBatchDatasetInst { op })
    }
}
impl DenseToSparseBatchDatasetInst {
    /// Returns the 'handle' Output of this 'DenseToSparseBatchDataset' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_dataset' Input of this 'DenseToSparseBatchDataset' operation.
    pub fn input_dataset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'batch_size' Input of this 'DenseToSparseBatchDataset' operation.
    pub fn batch_size(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'row_shape' Input of this 'DenseToSparseBatchDataset' operation.
    pub fn row_shape(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<DenseToSparseBatchDatasetInst> for crate::Operation {
    fn from(inst: DenseToSparseBatchDatasetInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `DenseToSparseBatchDataset::new().build(input_dataset, batch_size, row_shape, scope)`.
pub fn dense_to_sparse_batch_dataset<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    input_dataset: O0,
    batch_size: O1,
    row_shape: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    DenseToSparseBatchDataset::new().build(input_dataset, batch_size, row_shape, scope)
}

/// Builder for the `DenseToSparseSetOperation` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct DenseToSparseSetOperation {
    set_operation: ::std::option::Option<::std::string::String>,
    validate_indices: ::std::option::Option<bool>,
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'DenseToSparseSetOperation' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct DenseToSparseSetOperationInst {
    /// An instance of a fully built DenseToSparseSetOperation Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl DenseToSparseSetOperation {
    /// Creates a new `DenseToSparseSetOperation`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `set_operation` attribute.
    pub fn set_operation<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.set_operation = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `validate_indices` attribute.
    pub fn validate_indices<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.validate_indices = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `DenseToSparseSetOperation` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
    >(
        &self,
        set1: O0,
        set2_indices: O1,
        set2_values: O2,
        set2_shape: O3,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            set1.into(),
            set2_indices.into(),
            set2_values.into(),
            set2_shape.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        set1: crate::Output,
        set2_indices: crate::Output,
        set2_values: crate::Output,
        set2_shape: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("DenseToSparseSetOperation", |nd| {
            nd.add_input(set1);
            nd.add_input(set2_indices);
            nd.add_input(set2_values);
            nd.add_input(set2_shape);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.set_operation {
                nd.set_attr_string("set_operation", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.validate_indices {
                nd.set_attr_bool("validate_indices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'DenseToSparseSetOperation' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        set1: crate::Output,
        set2_indices: crate::Output,
        set2_values: crate::Output,
        set2_shape: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<DenseToSparseSetOperationInst> {
        let op = scope.new_operation("DenseToSparseSetOperation", |builder| {
            builder.add_input(set1);
            builder.add_input(set2_indices);
            builder.add_input(set2_values);
            builder.add_input(set2_shape);
            if let ::std::option::Option::Some(value) = &self.set_operation {
                builder.set_attr_string("set_operation", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.validate_indices {
                builder.set_attr_bool("validate_indices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(DenseToSparseSetOperationInst { op })
    }
}
impl DenseToSparseSetOperationInst {
    /// Returns the 'result_indices' Output of this 'DenseToSparseSetOperation' operation.
    pub fn result_indices(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'result_values' Output of this 'DenseToSparseSetOperation' operation.
    pub fn result_values(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'result_shape' Output of this 'DenseToSparseSetOperation' operation.
    pub fn result_shape(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns the 'set1' Input of this 'DenseToSparseSetOperation' operation.
    pub fn set1(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'set2_indices' Input of this 'DenseToSparseSetOperation' operation.
    pub fn set2_indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'set2_values' Input of this 'DenseToSparseSetOperation' operation.
    pub fn set2_values(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'set2_shape' Input of this 'DenseToSparseSetOperation' operation.
    pub fn set2_shape(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
}
impl From<DenseToSparseSetOperationInst> for crate::Operation {
    fn from(inst: DenseToSparseSetOperationInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `DenseToSparseSetOperation::new().build(set1, set2_indices, set2_values, set2_shape, scope)`.
pub fn dense_to_sparse_set_operation<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
>(
    set1: O0,
    set2_indices: O1,
    set2_values: O2,
    set2_shape: O3,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    DenseToSparseSetOperation::new().build(set1, set2_indices, set2_values, set2_shape, scope)
}

/// Builder for the `DepthToSpace` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct DepthToSpace {
    T: ::std::option::Option<crate::DataType>,
    block_size: ::std::option::Option<i64>,
    data_format: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'DepthToSpace' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct DepthToSpaceInst {
    /// An instance of a fully built DepthToSpace Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl DepthToSpace {
    /// Creates a new `DepthToSpace`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `block_size` attribute.
    pub fn block_size<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.block_size = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `data_format` attribute.
    pub fn data_format<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.data_format = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `DepthToSpace` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("DepthToSpace", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.block_size {
                nd.set_attr_int("block_size", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.data_format {
                nd.set_attr_string("data_format", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'DepthToSpace' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<DepthToSpaceInst> {
        let op = scope.new_operation("DepthToSpace", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.block_size {
                builder.set_attr_int("block_size", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.data_format {
                builder.set_attr_string("data_format", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(DepthToSpaceInst { op })
    }
}
impl DepthToSpaceInst {
    /// Returns the 'output' Output of this 'DepthToSpace' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'DepthToSpace' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<DepthToSpaceInst> for crate::Operation {
    fn from(inst: DepthToSpaceInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `DepthToSpace::new().build(input, scope)`.
pub fn depth_to_space<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    DepthToSpace::new().build(input, scope)
}

/// Builder for the `DepthwiseConv2dNative` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct DepthwiseConv2dNative {
    T: ::std::option::Option<crate::DataType>,
    strides: ::std::option::Option<::std::vec::Vec<i64>>,
    padding: ::std::option::Option<::std::string::String>,
    explicit_paddings: ::std::option::Option<::std::vec::Vec<i64>>,
    data_format: ::std::option::Option<::std::string::String>,
    dilations: ::std::option::Option<::std::vec::Vec<i64>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'DepthwiseConv2dNative' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct DepthwiseConv2dNativeInst {
    /// An instance of a fully built DepthwiseConv2dNative Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl DepthwiseConv2dNative {
    /// Creates a new `DepthwiseConv2dNative`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `strides` attribute.
    pub fn strides<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.strides = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `padding` attribute.
    pub fn padding<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.padding = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `explicit_paddings` attribute.
    pub fn explicit_paddings<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.explicit_paddings = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `data_format` attribute.
    pub fn data_format<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.data_format = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `dilations` attribute.
    pub fn dilations<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.dilations = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `DepthwiseConv2dNative` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        filter: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), filter.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        filter: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("DepthwiseConv2dNative", |nd| {
            nd.add_input(input);
            nd.add_input(filter);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.strides {
                nd.set_attr_int_list("strides", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding {
                nd.set_attr_string("padding", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.explicit_paddings {
                nd.set_attr_int_list("explicit_paddings", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.data_format {
                nd.set_attr_string("data_format", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dilations {
                nd.set_attr_int_list("dilations", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'DepthwiseConv2dNative' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        filter: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<DepthwiseConv2dNativeInst> {
        let op = scope.new_operation("DepthwiseConv2dNative", |builder| {
            builder.add_input(input);
            builder.add_input(filter);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.strides {
                builder.set_attr_int_list("strides", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding {
                builder.set_attr_string("padding", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.explicit_paddings {
                builder.set_attr_int_list("explicit_paddings", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.data_format {
                builder.set_attr_string("data_format", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dilations {
                builder.set_attr_int_list("dilations", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(DepthwiseConv2dNativeInst { op })
    }
}
impl DepthwiseConv2dNativeInst {
    /// Returns the 'output' Output of this 'DepthwiseConv2dNative' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'DepthwiseConv2dNative' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'filter' Input of this 'DepthwiseConv2dNative' operation.
    pub fn filter(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<DepthwiseConv2dNativeInst> for crate::Operation {
    fn from(inst: DepthwiseConv2dNativeInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `DepthwiseConv2dNative::new().build(input, filter, scope)`.
pub fn depthwise_conv2d_native<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    input: O0,
    filter: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    DepthwiseConv2dNative::new().build(input, filter, scope)
}

/// Builder for the `DepthwiseConv2dNativeBackpropFilter` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct DepthwiseConv2dNativeBackpropFilter {
    T: ::std::option::Option<crate::DataType>,
    strides: ::std::option::Option<::std::vec::Vec<i64>>,
    padding: ::std::option::Option<::std::string::String>,
    explicit_paddings: ::std::option::Option<::std::vec::Vec<i64>>,
    data_format: ::std::option::Option<::std::string::String>,
    dilations: ::std::option::Option<::std::vec::Vec<i64>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'DepthwiseConv2dNativeBackpropFilter' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct DepthwiseConv2dNativeBackpropFilterInst {
    /// An instance of a fully built DepthwiseConv2dNativeBackpropFilter Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl DepthwiseConv2dNativeBackpropFilter {
    /// Creates a new `DepthwiseConv2dNativeBackpropFilter`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `strides` attribute.
    pub fn strides<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.strides = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `padding` attribute.
    pub fn padding<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.padding = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `explicit_paddings` attribute.
    pub fn explicit_paddings<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.explicit_paddings = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `data_format` attribute.
    pub fn data_format<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.data_format = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `dilations` attribute.
    pub fn dilations<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.dilations = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `DepthwiseConv2dNativeBackpropFilter` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        filter_sizes: O1,
        out_backprop: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            input.into(),
            filter_sizes.into(),
            out_backprop.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        input: crate::Output,
        filter_sizes: crate::Output,
        out_backprop: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("DepthwiseConv2dNativeBackpropFilter", |nd| {
            nd.add_input(input);
            nd.add_input(filter_sizes);
            nd.add_input(out_backprop);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.strides {
                nd.set_attr_int_list("strides", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding {
                nd.set_attr_string("padding", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.explicit_paddings {
                nd.set_attr_int_list("explicit_paddings", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.data_format {
                nd.set_attr_string("data_format", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dilations {
                nd.set_attr_int_list("dilations", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'DepthwiseConv2dNativeBackpropFilter' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        filter_sizes: crate::Output,
        out_backprop: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<DepthwiseConv2dNativeBackpropFilterInst> {
        let op = scope.new_operation("DepthwiseConv2dNativeBackpropFilter", |builder| {
            builder.add_input(input);
            builder.add_input(filter_sizes);
            builder.add_input(out_backprop);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.strides {
                builder.set_attr_int_list("strides", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding {
                builder.set_attr_string("padding", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.explicit_paddings {
                builder.set_attr_int_list("explicit_paddings", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.data_format {
                builder.set_attr_string("data_format", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dilations {
                builder.set_attr_int_list("dilations", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(DepthwiseConv2dNativeBackpropFilterInst { op })
    }
}
impl DepthwiseConv2dNativeBackpropFilterInst {
    /// Returns the 'output' Output of this 'DepthwiseConv2dNativeBackpropFilter' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'DepthwiseConv2dNativeBackpropFilter' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'filter_sizes' Input of this 'DepthwiseConv2dNativeBackpropFilter' operation.
    pub fn filter_sizes(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'out_backprop' Input of this 'DepthwiseConv2dNativeBackpropFilter' operation.
    pub fn out_backprop(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<DepthwiseConv2dNativeBackpropFilterInst> for crate::Operation {
    fn from(inst: DepthwiseConv2dNativeBackpropFilterInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `DepthwiseConv2dNativeBackpropFilter::new().build(input, filter_sizes, out_backprop, scope)`.
pub fn depthwise_conv2d_native_backprop_filter<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    input: O0,
    filter_sizes: O1,
    out_backprop: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    DepthwiseConv2dNativeBackpropFilter::new().build(input, filter_sizes, out_backprop, scope)
}

/// Builder for the `DepthwiseConv2dNativeBackpropInput` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct DepthwiseConv2dNativeBackpropInput {
    T: ::std::option::Option<crate::DataType>,
    strides: ::std::option::Option<::std::vec::Vec<i64>>,
    padding: ::std::option::Option<::std::string::String>,
    explicit_paddings: ::std::option::Option<::std::vec::Vec<i64>>,
    data_format: ::std::option::Option<::std::string::String>,
    dilations: ::std::option::Option<::std::vec::Vec<i64>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'DepthwiseConv2dNativeBackpropInput' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct DepthwiseConv2dNativeBackpropInputInst {
    /// An instance of a fully built DepthwiseConv2dNativeBackpropInput Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl DepthwiseConv2dNativeBackpropInput {
    /// Creates a new `DepthwiseConv2dNativeBackpropInput`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `strides` attribute.
    pub fn strides<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.strides = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `padding` attribute.
    pub fn padding<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.padding = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `explicit_paddings` attribute.
    pub fn explicit_paddings<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.explicit_paddings = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `data_format` attribute.
    pub fn data_format<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.data_format = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `dilations` attribute.
    pub fn dilations<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.dilations = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `DepthwiseConv2dNativeBackpropInput` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input_sizes: O0,
        filter: O1,
        out_backprop: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            input_sizes.into(),
            filter.into(),
            out_backprop.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        input_sizes: crate::Output,
        filter: crate::Output,
        out_backprop: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("DepthwiseConv2dNativeBackpropInput", |nd| {
            nd.add_input(input_sizes);
            nd.add_input(filter);
            nd.add_input(out_backprop);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.strides {
                nd.set_attr_int_list("strides", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding {
                nd.set_attr_string("padding", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.explicit_paddings {
                nd.set_attr_int_list("explicit_paddings", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.data_format {
                nd.set_attr_string("data_format", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dilations {
                nd.set_attr_int_list("dilations", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'DepthwiseConv2dNativeBackpropInput' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_sizes: crate::Output,
        filter: crate::Output,
        out_backprop: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<DepthwiseConv2dNativeBackpropInputInst> {
        let op = scope.new_operation("DepthwiseConv2dNativeBackpropInput", |builder| {
            builder.add_input(input_sizes);
            builder.add_input(filter);
            builder.add_input(out_backprop);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.strides {
                builder.set_attr_int_list("strides", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding {
                builder.set_attr_string("padding", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.explicit_paddings {
                builder.set_attr_int_list("explicit_paddings", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.data_format {
                builder.set_attr_string("data_format", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dilations {
                builder.set_attr_int_list("dilations", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(DepthwiseConv2dNativeBackpropInputInst { op })
    }
}
impl DepthwiseConv2dNativeBackpropInputInst {
    /// Returns the 'output' Output of this 'DepthwiseConv2dNativeBackpropInput' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_sizes' Input of this 'DepthwiseConv2dNativeBackpropInput' operation.
    pub fn input_sizes(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'filter' Input of this 'DepthwiseConv2dNativeBackpropInput' operation.
    pub fn filter(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'out_backprop' Input of this 'DepthwiseConv2dNativeBackpropInput' operation.
    pub fn out_backprop(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<DepthwiseConv2dNativeBackpropInputInst> for crate::Operation {
    fn from(inst: DepthwiseConv2dNativeBackpropInputInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `DepthwiseConv2dNativeBackpropInput::new().build(input_sizes, filter, out_backprop, scope)`.
pub fn depthwise_conv2d_native_backprop_input<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    input_sizes: O0,
    filter: O1,
    out_backprop: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    DepthwiseConv2dNativeBackpropInput::new().build(input_sizes, filter, out_backprop, scope)
}

/// Builder for the `Dequantize` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Dequantize {
    T: ::std::option::Option<crate::DataType>,
    mode: ::std::option::Option<::std::string::String>,
    narrow_range: ::std::option::Option<bool>,
    axis: ::std::option::Option<i64>,
    dtype: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Dequantize' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct DequantizeInst {
    /// An instance of a fully built Dequantize Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Dequantize {
    /// Creates a new `Dequantize`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `mode` attribute.
    pub fn mode<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.mode = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `narrow_range` attribute.
    pub fn narrow_range<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.narrow_range = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `axis` attribute.
    pub fn axis<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.axis = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `dtype` attribute.
    pub fn dtype<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Dequantize` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        min_range: O1,
        max_range: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), min_range.into(), max_range.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        min_range: crate::Output,
        max_range: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Dequantize", |nd| {
            nd.add_input(input);
            nd.add_input(min_range);
            nd.add_input(max_range);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.mode {
                nd.set_attr_string("mode", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.narrow_range {
                nd.set_attr_bool("narrow_range", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.axis {
                nd.set_attr_int("axis", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                nd.set_attr_type("dtype", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Dequantize' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        min_range: crate::Output,
        max_range: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<DequantizeInst> {
        let op = scope.new_operation("Dequantize", |builder| {
            builder.add_input(input);
            builder.add_input(min_range);
            builder.add_input(max_range);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.mode {
                builder.set_attr_string("mode", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.narrow_range {
                builder.set_attr_bool("narrow_range", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.axis {
                builder.set_attr_int("axis", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                builder.set_attr_type("dtype", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(DequantizeInst { op })
    }
}
impl DequantizeInst {
    /// Returns the 'output' Output of this 'Dequantize' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'Dequantize' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'min_range' Input of this 'Dequantize' operation.
    pub fn min_range(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'max_range' Input of this 'Dequantize' operation.
    pub fn max_range(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<DequantizeInst> for crate::Operation {
    fn from(inst: DequantizeInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Dequantize::new().build(input, min_range, max_range, scope)`.
pub fn dequantize<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    input: O0,
    min_range: O1,
    max_range: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Dequantize::new().build(input, min_range, max_range, scope)
}

/// Builder for the `DeserializeIterator` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct DeserializeIterator {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'DeserializeIterator' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct DeserializeIteratorInst {
    /// An instance of a fully built DeserializeIterator Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl DeserializeIterator {
    /// Creates a new `DeserializeIterator`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `DeserializeIterator` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        resource_handle: O0,
        serialized: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(resource_handle.into(), serialized.into(), scope)
    }
    fn build_impl(
        &self,
        resource_handle: crate::Output,
        serialized: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("DeserializeIterator", |nd| {
            nd.add_input(resource_handle);
            nd.add_input(serialized);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'DeserializeIterator' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        resource_handle: crate::Output,
        serialized: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<DeserializeIteratorInst> {
        let op = scope.new_operation("DeserializeIterator", |builder| {
            builder.add_input(resource_handle);
            builder.add_input(serialized);
            ::std::result::Result::Ok(())
        })?;
        Ok(DeserializeIteratorInst { op })
    }
}
impl DeserializeIteratorInst {
    /// Returns the 'resource_handle' Input of this 'DeserializeIterator' operation.
    pub fn resource_handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'serialized' Input of this 'DeserializeIterator' operation.
    pub fn serialized(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<DeserializeIteratorInst> for crate::Operation {
    fn from(inst: DeserializeIteratorInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `DeserializeIterator::new().build(resource_handle, serialized, scope)`.
pub fn deserialize_iterator<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    resource_handle: O0,
    serialized: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    DeserializeIterator::new().build(resource_handle, serialized, scope)
}

/// Builder for the `DeserializeManySparse` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct DeserializeManySparse {
    dtype: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'DeserializeManySparse' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct DeserializeManySparseInst {
    /// An instance of a fully built DeserializeManySparse Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl DeserializeManySparse {
    /// Creates a new `DeserializeManySparse`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `dtype` attribute.
    pub fn dtype<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `DeserializeManySparse` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        serialized_sparse: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(serialized_sparse.into(), scope)
    }
    fn build_impl(
        &self,
        serialized_sparse: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("DeserializeManySparse", |nd| {
            nd.add_input(serialized_sparse);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                nd.set_attr_type("dtype", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'DeserializeManySparse' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        serialized_sparse: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<DeserializeManySparseInst> {
        let op = scope.new_operation("DeserializeManySparse", |builder| {
            builder.add_input(serialized_sparse);
            if let ::std::option::Option::Some(value) = &self.dtype {
                builder.set_attr_type("dtype", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(DeserializeManySparseInst { op })
    }
}
impl DeserializeManySparseInst {
    /// Returns the 'sparse_indices' Output of this 'DeserializeManySparse' operation.
    pub fn sparse_indices(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'sparse_values' Output of this 'DeserializeManySparse' operation.
    pub fn sparse_values(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'sparse_shape' Output of this 'DeserializeManySparse' operation.
    pub fn sparse_shape(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns the 'serialized_sparse' Input of this 'DeserializeManySparse' operation.
    pub fn serialized_sparse(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<DeserializeManySparseInst> for crate::Operation {
    fn from(inst: DeserializeManySparseInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `DeserializeManySparse::new().build(serialized_sparse, scope)`.
pub fn deserialize_many_sparse<O0: ::std::convert::Into<crate::Output>>(
    serialized_sparse: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    DeserializeManySparse::new().build(serialized_sparse, scope)
}

/// Builder for the `DeserializeSparse` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct DeserializeSparse {
    dtype: ::std::option::Option<crate::DataType>,
    Tserialized: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'DeserializeSparse' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct DeserializeSparseInst {
    /// An instance of a fully built DeserializeSparse Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl DeserializeSparse {
    /// Creates a new `DeserializeSparse`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `dtype` attribute.
    pub fn dtype<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tserialized` attribute.
    pub fn Tserialized<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tserialized = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `DeserializeSparse` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        serialized_sparse: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(serialized_sparse.into(), scope)
    }
    fn build_impl(
        &self,
        serialized_sparse: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("DeserializeSparse", |nd| {
            nd.add_input(serialized_sparse);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                nd.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tserialized {
                nd.set_attr_type("Tserialized", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'DeserializeSparse' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        serialized_sparse: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<DeserializeSparseInst> {
        let op = scope.new_operation("DeserializeSparse", |builder| {
            builder.add_input(serialized_sparse);
            if let ::std::option::Option::Some(value) = &self.dtype {
                builder.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tserialized {
                builder.set_attr_type("Tserialized", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(DeserializeSparseInst { op })
    }
}
impl DeserializeSparseInst {
    /// Returns the 'sparse_indices' Output of this 'DeserializeSparse' operation.
    pub fn sparse_indices(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'sparse_values' Output of this 'DeserializeSparse' operation.
    pub fn sparse_values(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'sparse_shape' Output of this 'DeserializeSparse' operation.
    pub fn sparse_shape(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns the 'serialized_sparse' Input of this 'DeserializeSparse' operation.
    pub fn serialized_sparse(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<DeserializeSparseInst> for crate::Operation {
    fn from(inst: DeserializeSparseInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `DeserializeSparse::new().build(serialized_sparse, scope)`.
pub fn deserialize_sparse<O0: ::std::convert::Into<crate::Output>>(
    serialized_sparse: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    DeserializeSparse::new().build(serialized_sparse, scope)
}

/// Builder for the `DestroyResourceOp` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct DestroyResourceOp {
    ignore_lookup_error: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'DestroyResourceOp' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct DestroyResourceOpInst {
    /// An instance of a fully built DestroyResourceOp Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl DestroyResourceOp {
    /// Creates a new `DestroyResourceOp`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `ignore_lookup_error` attribute.
    pub fn ignore_lookup_error<ArgType: ::std::convert::Into<bool>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.ignore_lookup_error = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `DestroyResourceOp` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        resource: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(resource.into(), scope)
    }
    fn build_impl(
        &self,
        resource: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("DestroyResourceOp", |nd| {
            nd.add_input(resource);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.ignore_lookup_error {
                nd.set_attr_bool("ignore_lookup_error", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'DestroyResourceOp' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        resource: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<DestroyResourceOpInst> {
        let op = scope.new_operation("DestroyResourceOp", |builder| {
            builder.add_input(resource);
            if let ::std::option::Option::Some(value) = &self.ignore_lookup_error {
                builder.set_attr_bool("ignore_lookup_error", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(DestroyResourceOpInst { op })
    }
}
impl DestroyResourceOpInst {
    /// Returns the 'resource' Input of this 'DestroyResourceOp' operation.
    pub fn resource(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<DestroyResourceOpInst> for crate::Operation {
    fn from(inst: DestroyResourceOpInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `DestroyResourceOp::new().build(resource, scope)`.
pub fn destroy_resource_op<O0: ::std::convert::Into<crate::Output>>(
    resource: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    DestroyResourceOp::new().build(resource, scope)
}

/// Builder for the `DestroyTemporaryVariable` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct DestroyTemporaryVariable {
    T: ::std::option::Option<crate::DataType>,
    var_name: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'DestroyTemporaryVariable' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct DestroyTemporaryVariableInst {
    /// An instance of a fully built DestroyTemporaryVariable Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl DestroyTemporaryVariable {
    /// Creates a new `DestroyTemporaryVariable`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `var_name` attribute.
    pub fn var_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.var_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `DestroyTemporaryVariable` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        ref_: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(ref_.into(), scope)
    }
    fn build_impl(
        &self,
        ref_: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("DestroyTemporaryVariable", |nd| {
            nd.add_input(ref_);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.var_name {
                nd.set_attr_string("var_name", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'DestroyTemporaryVariable' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        ref_: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<DestroyTemporaryVariableInst> {
        let op = scope.new_operation("DestroyTemporaryVariable", |builder| {
            builder.add_input(ref_);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.var_name {
                builder.set_attr_string("var_name", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(DestroyTemporaryVariableInst { op })
    }
}
impl DestroyTemporaryVariableInst {
    /// Returns the 'value' Output of this 'DestroyTemporaryVariable' operation.
    pub fn value(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'ref_' Input of this 'DestroyTemporaryVariable' operation.
    pub fn ref_(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<DestroyTemporaryVariableInst> for crate::Operation {
    fn from(inst: DestroyTemporaryVariableInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `DestroyTemporaryVariable::new().build(ref_, scope)`.
pub fn destroy_temporary_variable<O0: ::std::convert::Into<crate::Output>>(
    ref_: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    DestroyTemporaryVariable::new().build(ref_, scope)
}

/// Builder for the `DeviceIndex` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct DeviceIndex {
    device_names: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'DeviceIndex' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct DeviceIndexInst {
    /// An instance of a fully built DeviceIndex Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl DeviceIndex {
    /// Creates a new `DeviceIndex`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `device_names` attribute.
    pub fn device_names<ArgType: ::std::convert::Into<::std::vec::Vec<::std::string::String>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.device_names = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `DeviceIndex` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("DeviceIndex", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.device_names {
                nd.set_attr_string_list("device_names", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'DeviceIndex' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(&self, scope: &mut crate::Scope) -> crate::Result<DeviceIndexInst> {
        let op = scope.new_operation("DeviceIndex", |builder| {
            if let ::std::option::Option::Some(value) = &self.device_names {
                builder.set_attr_string_list("device_names", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(DeviceIndexInst { op })
    }
}
impl DeviceIndexInst {
    /// Returns the 'index' Output of this 'DeviceIndex' operation.
    pub fn index(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
}
impl From<DeviceIndexInst> for crate::Operation {
    fn from(inst: DeviceIndexInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `DeviceIndex::new().build(scope)`.
pub fn device_index(scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
    DeviceIndex::new().build(scope)
}

/// Builder for the `Diag` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Diag {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Diag' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct DiagInst {
    /// An instance of a fully built Diag Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Diag {
    /// Creates a new `Diag`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Diag` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        diagonal: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(diagonal.into(), scope)
    }
    fn build_impl(
        &self,
        diagonal: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Diag", |nd| {
            nd.add_input(diagonal);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Diag' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        diagonal: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<DiagInst> {
        let op = scope.new_operation("Diag", |builder| {
            builder.add_input(diagonal);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(DiagInst { op })
    }
}
impl DiagInst {
    /// Returns the 'output' Output of this 'Diag' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'diagonal' Input of this 'Diag' operation.
    pub fn diagonal(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<DiagInst> for crate::Operation {
    fn from(inst: DiagInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Diag::new().build(diagonal, scope)`.
pub fn diag<O0: ::std::convert::Into<crate::Output>>(
    diagonal: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Diag::new().build(diagonal, scope)
}

/// Builder for the `DiagPart` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct DiagPart {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'DiagPart' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct DiagPartInst {
    /// An instance of a fully built DiagPart Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl DiagPart {
    /// Creates a new `DiagPart`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `DiagPart` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("DiagPart", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'DiagPart' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<DiagPartInst> {
        let op = scope.new_operation("DiagPart", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(DiagPartInst { op })
    }
}
impl DiagPartInst {
    /// Returns the 'diagonal' Output of this 'DiagPart' operation.
    pub fn diagonal(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'DiagPart' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<DiagPartInst> for crate::Operation {
    fn from(inst: DiagPartInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `DiagPart::new().build(input, scope)`.
pub fn diag_part<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    DiagPart::new().build(input, scope)
}

/// Builder for the `Digamma` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Digamma {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Digamma' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct DigammaInst {
    /// An instance of a fully built Digamma Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Digamma {
    /// Creates a new `Digamma`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Digamma` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        x: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Digamma", |nd| {
            nd.add_input(x);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Digamma' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<DigammaInst> {
        let op = scope.new_operation("Digamma", |builder| {
            builder.add_input(x);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(DigammaInst { op })
    }
}
impl DigammaInst {
    /// Returns the 'y' Output of this 'Digamma' operation.
    pub fn y(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'Digamma' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<DigammaInst> for crate::Operation {
    fn from(inst: DigammaInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Digamma::new().build(x, scope)`.
pub fn digamma<O0: ::std::convert::Into<crate::Output>>(
    x: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Digamma::new().build(x, scope)
}

/// Builder for the `Dilation2D` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Dilation2D {
    T: ::std::option::Option<crate::DataType>,
    strides: ::std::option::Option<::std::vec::Vec<i64>>,
    rates: ::std::option::Option<::std::vec::Vec<i64>>,
    padding: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Dilation2D' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct Dilation2DInst {
    /// An instance of a fully built Dilation2D Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Dilation2D {
    /// Creates a new `Dilation2D`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `strides` attribute.
    pub fn strides<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.strides = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `rates` attribute.
    pub fn rates<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.rates = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `padding` attribute.
    pub fn padding<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.padding = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Dilation2D` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        filter: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), filter.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        filter: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Dilation2D", |nd| {
            nd.add_input(input);
            nd.add_input(filter);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.strides {
                nd.set_attr_int_list("strides", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.rates {
                nd.set_attr_int_list("rates", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding {
                nd.set_attr_string("padding", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Dilation2D' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        filter: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<Dilation2DInst> {
        let op = scope.new_operation("Dilation2D", |builder| {
            builder.add_input(input);
            builder.add_input(filter);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.strides {
                builder.set_attr_int_list("strides", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.rates {
                builder.set_attr_int_list("rates", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding {
                builder.set_attr_string("padding", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(Dilation2DInst { op })
    }
}
impl Dilation2DInst {
    /// Returns the 'output' Output of this 'Dilation2D' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'Dilation2D' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'filter' Input of this 'Dilation2D' operation.
    pub fn filter(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<Dilation2DInst> for crate::Operation {
    fn from(inst: Dilation2DInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Dilation2D::new().build(input, filter, scope)`.
pub fn dilation2_d<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    input: O0,
    filter: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Dilation2D::new().build(input, filter, scope)
}

/// Builder for the `Dilation2DBackpropFilter` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Dilation2DBackpropFilter {
    T: ::std::option::Option<crate::DataType>,
    strides: ::std::option::Option<::std::vec::Vec<i64>>,
    rates: ::std::option::Option<::std::vec::Vec<i64>>,
    padding: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Dilation2DBackpropFilter' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct Dilation2DBackpropFilterInst {
    /// An instance of a fully built Dilation2DBackpropFilter Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Dilation2DBackpropFilter {
    /// Creates a new `Dilation2DBackpropFilter`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `strides` attribute.
    pub fn strides<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.strides = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `rates` attribute.
    pub fn rates<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.rates = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `padding` attribute.
    pub fn padding<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.padding = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Dilation2DBackpropFilter` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        filter: O1,
        out_backprop: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), filter.into(), out_backprop.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        filter: crate::Output,
        out_backprop: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Dilation2DBackpropFilter", |nd| {
            nd.add_input(input);
            nd.add_input(filter);
            nd.add_input(out_backprop);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.strides {
                nd.set_attr_int_list("strides", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.rates {
                nd.set_attr_int_list("rates", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding {
                nd.set_attr_string("padding", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Dilation2DBackpropFilter' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        filter: crate::Output,
        out_backprop: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<Dilation2DBackpropFilterInst> {
        let op = scope.new_operation("Dilation2DBackpropFilter", |builder| {
            builder.add_input(input);
            builder.add_input(filter);
            builder.add_input(out_backprop);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.strides {
                builder.set_attr_int_list("strides", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.rates {
                builder.set_attr_int_list("rates", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding {
                builder.set_attr_string("padding", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(Dilation2DBackpropFilterInst { op })
    }
}
impl Dilation2DBackpropFilterInst {
    /// Returns the 'filter_backprop' Output of this 'Dilation2DBackpropFilter' operation.
    pub fn filter_backprop(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'Dilation2DBackpropFilter' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'filter' Input of this 'Dilation2DBackpropFilter' operation.
    pub fn filter(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'out_backprop' Input of this 'Dilation2DBackpropFilter' operation.
    pub fn out_backprop(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<Dilation2DBackpropFilterInst> for crate::Operation {
    fn from(inst: Dilation2DBackpropFilterInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Dilation2DBackpropFilter::new().build(input, filter, out_backprop, scope)`.
pub fn dilation2_dbackprop_filter<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    input: O0,
    filter: O1,
    out_backprop: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Dilation2DBackpropFilter::new().build(input, filter, out_backprop, scope)
}

/// Builder for the `Dilation2DBackpropInput` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Dilation2DBackpropInput {
    T: ::std::option::Option<crate::DataType>,
    strides: ::std::option::Option<::std::vec::Vec<i64>>,
    rates: ::std::option::Option<::std::vec::Vec<i64>>,
    padding: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Dilation2DBackpropInput' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct Dilation2DBackpropInputInst {
    /// An instance of a fully built Dilation2DBackpropInput Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Dilation2DBackpropInput {
    /// Creates a new `Dilation2DBackpropInput`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `strides` attribute.
    pub fn strides<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.strides = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `rates` attribute.
    pub fn rates<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.rates = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `padding` attribute.
    pub fn padding<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.padding = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Dilation2DBackpropInput` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        filter: O1,
        out_backprop: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), filter.into(), out_backprop.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        filter: crate::Output,
        out_backprop: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Dilation2DBackpropInput", |nd| {
            nd.add_input(input);
            nd.add_input(filter);
            nd.add_input(out_backprop);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.strides {
                nd.set_attr_int_list("strides", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.rates {
                nd.set_attr_int_list("rates", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding {
                nd.set_attr_string("padding", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Dilation2DBackpropInput' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        filter: crate::Output,
        out_backprop: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<Dilation2DBackpropInputInst> {
        let op = scope.new_operation("Dilation2DBackpropInput", |builder| {
            builder.add_input(input);
            builder.add_input(filter);
            builder.add_input(out_backprop);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.strides {
                builder.set_attr_int_list("strides", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.rates {
                builder.set_attr_int_list("rates", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding {
                builder.set_attr_string("padding", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(Dilation2DBackpropInputInst { op })
    }
}
impl Dilation2DBackpropInputInst {
    /// Returns the 'in_backprop' Output of this 'Dilation2DBackpropInput' operation.
    pub fn in_backprop(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'Dilation2DBackpropInput' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'filter' Input of this 'Dilation2DBackpropInput' operation.
    pub fn filter(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'out_backprop' Input of this 'Dilation2DBackpropInput' operation.
    pub fn out_backprop(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<Dilation2DBackpropInputInst> for crate::Operation {
    fn from(inst: Dilation2DBackpropInputInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Dilation2DBackpropInput::new().build(input, filter, out_backprop, scope)`.
pub fn dilation2_dbackprop_input<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    input: O0,
    filter: O1,
    out_backprop: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Dilation2DBackpropInput::new().build(input, filter, out_backprop, scope)
}

/// Builder for the `DirectedInterleaveDataset` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct DirectedInterleaveDataset {
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    N: ::std::option::Option<i64>,
    stop_on_empty_dataset: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'DirectedInterleaveDataset' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct DirectedInterleaveDatasetInst {
    /// An instance of a fully built DirectedInterleaveDataset Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl DirectedInterleaveDataset {
    /// Creates a new `DirectedInterleaveDataset`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `N` attribute.
    pub fn N<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.N = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `stop_on_empty_dataset` attribute.
    pub fn stop_on_empty_dataset<ArgType: ::std::convert::Into<bool>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.stop_on_empty_dataset = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `DirectedInterleaveDataset` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        selector_input_dataset: O0,
        data_input_datasets: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            selector_input_dataset.into(),
            data_input_datasets.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        selector_input_dataset: crate::Output,
        data_input_datasets: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("DirectedInterleaveDataset", |nd| {
            nd.add_input(selector_input_dataset);
            nd.add_input(data_input_datasets);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.N {
                nd.set_attr_int("N", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.stop_on_empty_dataset {
                nd.set_attr_bool("stop_on_empty_dataset", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'DirectedInterleaveDataset' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        selector_input_dataset: crate::Output,
        data_input_datasets: Vec<crate::Output>,
        scope: &mut crate::Scope,
    ) -> crate::Result<DirectedInterleaveDatasetInst> {
        let op = scope.new_operation("DirectedInterleaveDataset", |builder| {
            builder.add_input(selector_input_dataset);
            builder.add_input_list(&data_input_datasets);
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            builder.set_attr_int("N", data_input_datasets.clone().len() as i64)?;
            if let ::std::option::Option::Some(value) = &self.stop_on_empty_dataset {
                builder.set_attr_bool("stop_on_empty_dataset", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(DirectedInterleaveDatasetInst { op })
    }
}
impl DirectedInterleaveDatasetInst {
    /// Returns the 'handle' Output of this 'DirectedInterleaveDataset' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'selector_input_dataset' Input of this 'DirectedInterleaveDataset' operation.
    pub fn selector_input_dataset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns a Vector of data_input_datasets for 'data_input_datasets' Input of this DirectedInterleaveDataset operation.
    pub fn data_input_datasets(&self) -> crate::Result<Vec<crate::Input>> {
        let mut Inputs = vec![];
        for i in 1..self.op.get_attr_int("N")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
}
impl From<DirectedInterleaveDatasetInst> for crate::Operation {
    fn from(inst: DirectedInterleaveDatasetInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `DirectedInterleaveDataset::new().build(selector_input_dataset, data_input_datasets, scope)`.
pub fn directed_interleave_dataset<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    selector_input_dataset: O0,
    data_input_datasets: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    DirectedInterleaveDataset::new().build(selector_input_dataset, data_input_datasets, scope)
}

/// Builder for the `DisableCopyOnRead` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct DisableCopyOnRead {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'DisableCopyOnRead' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct DisableCopyOnReadInst {
    /// An instance of a fully built DisableCopyOnRead Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl DisableCopyOnRead {
    /// Creates a new `DisableCopyOnRead`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `DisableCopyOnRead` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        resource: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(resource.into(), scope)
    }
    fn build_impl(
        &self,
        resource: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("DisableCopyOnRead", |nd| {
            nd.add_input(resource);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'DisableCopyOnRead' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        resource: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<DisableCopyOnReadInst> {
        let op = scope.new_operation("DisableCopyOnRead", |builder| {
            builder.add_input(resource);
            ::std::result::Result::Ok(())
        })?;
        Ok(DisableCopyOnReadInst { op })
    }
}
impl DisableCopyOnReadInst {
    /// Returns the 'resource' Input of this 'DisableCopyOnRead' operation.
    pub fn resource(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<DisableCopyOnReadInst> for crate::Operation {
    fn from(inst: DisableCopyOnReadInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `DisableCopyOnRead::new().build(resource, scope)`.
pub fn disable_copy_on_read<O0: ::std::convert::Into<crate::Output>>(
    resource: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    DisableCopyOnRead::new().build(resource, scope)
}

/// Builder for the `DistributedSave` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct DistributedSave {
    metadata: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'DistributedSave' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct DistributedSaveInst {
    /// An instance of a fully built DistributedSave Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl DistributedSave {
    /// Creates a new `DistributedSave`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `metadata` attribute.
    pub fn metadata<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.metadata = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `DistributedSave` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        dataset: O0,
        directory: O1,
        address: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(dataset.into(), directory.into(), address.into(), scope)
    }
    fn build_impl(
        &self,
        dataset: crate::Output,
        directory: crate::Output,
        address: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("DistributedSave", |nd| {
            nd.add_input(dataset);
            nd.add_input(directory);
            nd.add_input(address);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.metadata {
                nd.set_attr_string("metadata", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'DistributedSave' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        dataset: crate::Output,
        directory: crate::Output,
        address: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<DistributedSaveInst> {
        let op = scope.new_operation("DistributedSave", |builder| {
            builder.add_input(dataset);
            builder.add_input(directory);
            builder.add_input(address);
            if let ::std::option::Option::Some(value) = &self.metadata {
                builder.set_attr_string("metadata", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(DistributedSaveInst { op })
    }
}
impl DistributedSaveInst {
    /// Returns the 'dataset' Input of this 'DistributedSave' operation.
    pub fn dataset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'directory' Input of this 'DistributedSave' operation.
    pub fn directory(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'address' Input of this 'DistributedSave' operation.
    pub fn address(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<DistributedSaveInst> for crate::Operation {
    fn from(inst: DistributedSaveInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `DistributedSave::new().build(dataset, directory, address, scope)`.
pub fn distributed_save<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    dataset: O0,
    directory: O1,
    address: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    DistributedSave::new().build(dataset, directory, address, scope)
}

/// Builder for the `Div` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Div {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Div' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct DivInst {
    /// An instance of a fully built Div Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Div {
    /// Creates a new `Div`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Div` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        x: O0,
        y: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), y.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        y: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Div", |nd| {
            nd.add_input(x);
            nd.add_input(y);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Div' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        y: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<DivInst> {
        let op = scope.new_operation("Div", |builder| {
            builder.add_input(x);
            builder.add_input(y);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(DivInst { op })
    }
}
impl DivInst {
    /// Returns the 'z' Output of this 'Div' operation.
    pub fn z(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'Div' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'y' Input of this 'Div' operation.
    pub fn y(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<DivInst> for crate::Operation {
    fn from(inst: DivInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Div::new().build(x, y, scope)`.
pub fn div<O0: ::std::convert::Into<crate::Output>, O1: ::std::convert::Into<crate::Output>>(
    x: O0,
    y: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Div::new().build(x, y, scope)
}

/// Builder for the `DivNoNan` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct DivNoNan {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'DivNoNan' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct DivNoNanInst {
    /// An instance of a fully built DivNoNan Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl DivNoNan {
    /// Creates a new `DivNoNan`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `DivNoNan` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        x: O0,
        y: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), y.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        y: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("DivNoNan", |nd| {
            nd.add_input(x);
            nd.add_input(y);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'DivNoNan' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        y: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<DivNoNanInst> {
        let op = scope.new_operation("DivNoNan", |builder| {
            builder.add_input(x);
            builder.add_input(y);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(DivNoNanInst { op })
    }
}
impl DivNoNanInst {
    /// Returns the 'z' Output of this 'DivNoNan' operation.
    pub fn z(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'DivNoNan' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'y' Input of this 'DivNoNan' operation.
    pub fn y(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<DivNoNanInst> for crate::Operation {
    fn from(inst: DivNoNanInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `DivNoNan::new().build(x, y, scope)`.
pub fn div_no_nan<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    x: O0,
    y: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    DivNoNan::new().build(x, y, scope)
}

/// Builder for the `DrawBoundingBoxes` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct DrawBoundingBoxes {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'DrawBoundingBoxes' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct DrawBoundingBoxesInst {
    /// An instance of a fully built DrawBoundingBoxes Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl DrawBoundingBoxes {
    /// Creates a new `DrawBoundingBoxes`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `DrawBoundingBoxes` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        images: O0,
        boxes: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(images.into(), boxes.into(), scope)
    }
    fn build_impl(
        &self,
        images: crate::Output,
        boxes: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("DrawBoundingBoxes", |nd| {
            nd.add_input(images);
            nd.add_input(boxes);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'DrawBoundingBoxes' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        images: crate::Output,
        boxes: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<DrawBoundingBoxesInst> {
        let op = scope.new_operation("DrawBoundingBoxes", |builder| {
            builder.add_input(images);
            builder.add_input(boxes);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(DrawBoundingBoxesInst { op })
    }
}
impl DrawBoundingBoxesInst {
    /// Returns the 'output' Output of this 'DrawBoundingBoxes' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'images' Input of this 'DrawBoundingBoxes' operation.
    pub fn images(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'boxes' Input of this 'DrawBoundingBoxes' operation.
    pub fn boxes(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<DrawBoundingBoxesInst> for crate::Operation {
    fn from(inst: DrawBoundingBoxesInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `DrawBoundingBoxes::new().build(images, boxes, scope)`.
pub fn draw_bounding_boxes<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    images: O0,
    boxes: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    DrawBoundingBoxes::new().build(images, boxes, scope)
}

/// Builder for the `DrawBoundingBoxesV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct DrawBoundingBoxesV2 {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'DrawBoundingBoxesV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct DrawBoundingBoxesV2Inst {
    /// An instance of a fully built DrawBoundingBoxesV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl DrawBoundingBoxesV2 {
    /// Creates a new `DrawBoundingBoxesV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `DrawBoundingBoxesV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        images: O0,
        boxes: O1,
        colors: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(images.into(), boxes.into(), colors.into(), scope)
    }
    fn build_impl(
        &self,
        images: crate::Output,
        boxes: crate::Output,
        colors: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("DrawBoundingBoxesV2", |nd| {
            nd.add_input(images);
            nd.add_input(boxes);
            nd.add_input(colors);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'DrawBoundingBoxesV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        images: crate::Output,
        boxes: crate::Output,
        colors: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<DrawBoundingBoxesV2Inst> {
        let op = scope.new_operation("DrawBoundingBoxesV2", |builder| {
            builder.add_input(images);
            builder.add_input(boxes);
            builder.add_input(colors);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(DrawBoundingBoxesV2Inst { op })
    }
}
impl DrawBoundingBoxesV2Inst {
    /// Returns the 'output' Output of this 'DrawBoundingBoxesV2' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'images' Input of this 'DrawBoundingBoxesV2' operation.
    pub fn images(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'boxes' Input of this 'DrawBoundingBoxesV2' operation.
    pub fn boxes(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'colors' Input of this 'DrawBoundingBoxesV2' operation.
    pub fn colors(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<DrawBoundingBoxesV2Inst> for crate::Operation {
    fn from(inst: DrawBoundingBoxesV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `DrawBoundingBoxesV2::new().build(images, boxes, colors, scope)`.
pub fn draw_bounding_boxes_v2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    images: O0,
    boxes: O1,
    colors: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    DrawBoundingBoxesV2::new().build(images, boxes, colors, scope)
}

/// Builder for the `DummyIterationCounter` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct DummyIterationCounter {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'DummyIterationCounter' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct DummyIterationCounterInst {
    /// An instance of a fully built DummyIterationCounter Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl DummyIterationCounter {
    /// Creates a new `DummyIterationCounter`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `DummyIterationCounter` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("DummyIterationCounter", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'DummyIterationCounter' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        scope: &mut crate::Scope,
    ) -> crate::Result<DummyIterationCounterInst> {
        let op = scope.new_operation("DummyIterationCounter", |builder| {
            ::std::result::Result::Ok(())
        })?;
        Ok(DummyIterationCounterInst { op })
    }
}
impl DummyIterationCounterInst {
    /// Returns the 'handle' Output of this 'DummyIterationCounter' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
}
impl From<DummyIterationCounterInst> for crate::Operation {
    fn from(inst: DummyIterationCounterInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `DummyIterationCounter::new().build(scope)`.
pub fn dummy_iteration_counter(scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
    DummyIterationCounter::new().build(scope)
}

/// Builder for the `DummyMemoryCache` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct DummyMemoryCache {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'DummyMemoryCache' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct DummyMemoryCacheInst {
    /// An instance of a fully built DummyMemoryCache Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl DummyMemoryCache {
    /// Creates a new `DummyMemoryCache`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `DummyMemoryCache` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("DummyMemoryCache", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'DummyMemoryCache' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(&self, scope: &mut crate::Scope) -> crate::Result<DummyMemoryCacheInst> {
        let op =
            scope.new_operation("DummyMemoryCache", |builder| ::std::result::Result::Ok(()))?;
        Ok(DummyMemoryCacheInst { op })
    }
}
impl DummyMemoryCacheInst {
    /// Returns the 'handle' Output of this 'DummyMemoryCache' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
}
impl From<DummyMemoryCacheInst> for crate::Operation {
    fn from(inst: DummyMemoryCacheInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `DummyMemoryCache::new().build(scope)`.
pub fn dummy_memory_cache(scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
    DummyMemoryCache::new().build(scope)
}

/// Builder for the `DummySeedGenerator` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct DummySeedGenerator {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'DummySeedGenerator' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct DummySeedGeneratorInst {
    /// An instance of a fully built DummySeedGenerator Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl DummySeedGenerator {
    /// Creates a new `DummySeedGenerator`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `DummySeedGenerator` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("DummySeedGenerator", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'DummySeedGenerator' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        scope: &mut crate::Scope,
    ) -> crate::Result<DummySeedGeneratorInst> {
        let op =
            scope.new_operation(
                "DummySeedGenerator",
                |builder| ::std::result::Result::Ok(()),
            )?;
        Ok(DummySeedGeneratorInst { op })
    }
}
impl DummySeedGeneratorInst {
    /// Returns the 'handle' Output of this 'DummySeedGenerator' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
}
impl From<DummySeedGeneratorInst> for crate::Operation {
    fn from(inst: DummySeedGeneratorInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `DummySeedGenerator::new().build(scope)`.
pub fn dummy_seed_generator(scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
    DummySeedGenerator::new().build(scope)
}

/// Builder for the `DynamicEnqueueTPUEmbeddingArbitraryTensorBatch` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct DynamicEnqueueTPUEmbeddingArbitraryTensorBatch {
    T1: ::std::option::Option<crate::DataType>,
    T2: ::std::option::Option<crate::DataType>,
    T3: ::std::option::Option<crate::DataType>,
    N: ::std::option::Option<i64>,
    combiners: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'DynamicEnqueueTPUEmbeddingArbitraryTensorBatch' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct DynamicEnqueueTPUEmbeddingArbitraryTensorBatchInst {
    /// An instance of a fully built DynamicEnqueueTPUEmbeddingArbitraryTensorBatch Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl DynamicEnqueueTPUEmbeddingArbitraryTensorBatch {
    /// Creates a new `DynamicEnqueueTPUEmbeddingArbitraryTensorBatch`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T1` attribute.
    pub fn T1<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T1 = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T2` attribute.
    pub fn T2<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T2 = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T3` attribute.
    pub fn T3<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T3 = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `N` attribute.
    pub fn N<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.N = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `combiners` attribute.
    pub fn combiners<ArgType: ::std::convert::Into<::std::vec::Vec<::std::string::String>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.combiners = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `DynamicEnqueueTPUEmbeddingArbitraryTensorBatch` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
    >(
        &self,
        sample_indices_or_row_splits: O0,
        embedding_indices: O1,
        aggregation_weights: O2,
        mode_override: O3,
        device_ordinal: O4,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            sample_indices_or_row_splits.into(),
            embedding_indices.into(),
            aggregation_weights.into(),
            mode_override.into(),
            device_ordinal.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        sample_indices_or_row_splits: crate::Output,
        embedding_indices: crate::Output,
        aggregation_weights: crate::Output,
        mode_override: crate::Output,
        device_ordinal: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("DynamicEnqueueTPUEmbeddingArbitraryTensorBatch", |nd| {
            nd.add_input(sample_indices_or_row_splits);
            nd.add_input(embedding_indices);
            nd.add_input(aggregation_weights);
            nd.add_input(mode_override);
            nd.add_input(device_ordinal);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T1 {
                nd.set_attr_type("T1", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T2 {
                nd.set_attr_type("T2", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T3 {
                nd.set_attr_type("T3", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.N {
                nd.set_attr_int("N", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.combiners {
                nd.set_attr_string_list("combiners", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'DynamicEnqueueTPUEmbeddingArbitraryTensorBatch' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        sample_indices_or_row_splits: Vec<crate::Output>,
        embedding_indices: Vec<crate::Output>,
        aggregation_weights: Vec<crate::Output>,
        mode_override: crate::Output,
        device_ordinal: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<DynamicEnqueueTPUEmbeddingArbitraryTensorBatchInst> {
        let op = scope.new_operation(
            "DynamicEnqueueTPUEmbeddingArbitraryTensorBatch",
            |builder| {
                builder.add_input_list(&sample_indices_or_row_splits);
                builder.add_input_list(&embedding_indices);
                builder.add_input_list(&aggregation_weights);
                builder.add_input(mode_override);
                builder.add_input(device_ordinal);
                if let ::std::option::Option::Some(value) = &self.T1 {
                    builder.set_attr_type("T1", *value)?;
                }
                if let ::std::option::Option::Some(value) = &self.T2 {
                    builder.set_attr_type("T2", *value)?;
                }
                if let ::std::option::Option::Some(value) = &self.T3 {
                    builder.set_attr_type("T3", *value)?;
                }
                builder.set_attr_int("N", sample_indices_or_row_splits.clone().len() as i64)?;
                if let ::std::option::Option::Some(value) = &self.combiners {
                    builder.set_attr_string_list("combiners", value)?;
                }
                ::std::result::Result::Ok(())
            },
        )?;
        Ok(DynamicEnqueueTPUEmbeddingArbitraryTensorBatchInst { op })
    }
}
impl DynamicEnqueueTPUEmbeddingArbitraryTensorBatchInst {
    /// Returns a Vector of sample_indices_or_row_splits for 'sample_indices_or_row_splits' Input of this DynamicEnqueueTPUEmbeddingArbitraryTensorBatch operation.
    pub fn sample_indices_or_row_splits(&self) -> crate::Result<Vec<crate::Input>> {
        let mut Inputs = vec![];
        for i in 0..self.op.get_attr_int("N")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
    /// Returns a Vector of embedding_indices for 'embedding_indices' Input of this DynamicEnqueueTPUEmbeddingArbitraryTensorBatch operation.
    pub fn embedding_indices(&self) -> crate::Result<Vec<crate::Input>> {
        let dynamic_offset = (self.op.get_attr_int("N")? + 1) as i32;
        let mut Inputs = vec![];
        for i in dynamic_offset..dynamic_offset + self.op.get_attr_int("N")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
    /// Returns a Vector of aggregation_weights for 'aggregation_weights' Input of this DynamicEnqueueTPUEmbeddingArbitraryTensorBatch operation.
    pub fn aggregation_weights(&self) -> crate::Result<Vec<crate::Input>> {
        let dynamic_offset = (2 * self.op.get_attr_int("N")? + 2) as i32;
        let mut Inputs = vec![];
        for i in dynamic_offset..dynamic_offset + self.op.get_attr_int("N")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
    /// Returns the 'mode_override' Input of this 'DynamicEnqueueTPUEmbeddingArbitraryTensorBatch' operation.
    pub fn mode_override(&self) -> crate::Result<crate::Input> {
        let dynamic_offset = (3 * self.op.get_attr_int("N")? + 3) as i32;
        Ok(crate::Input {
            operation: &self.op,
            index: dynamic_offset,
        })
    }
    /// Returns the 'device_ordinal' Input of this 'DynamicEnqueueTPUEmbeddingArbitraryTensorBatch' operation.
    pub fn device_ordinal(&self) -> crate::Result<crate::Input> {
        let dynamic_offset = (3 * self.op.get_attr_int("N")? + 4) as i32;
        Ok(crate::Input {
            operation: &self.op,
            index: dynamic_offset,
        })
    }
}
impl From<DynamicEnqueueTPUEmbeddingArbitraryTensorBatchInst> for crate::Operation {
    fn from(inst: DynamicEnqueueTPUEmbeddingArbitraryTensorBatchInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `DynamicEnqueueTPUEmbeddingArbitraryTensorBatch::new().build(sample_indices_or_row_splits, embedding_indices, aggregation_weights, mode_override, device_ordinal, scope)`.
pub fn dynamic_enqueue_tpuembedding_arbitrary_tensor_batch<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
>(
    sample_indices_or_row_splits: O0,
    embedding_indices: O1,
    aggregation_weights: O2,
    mode_override: O3,
    device_ordinal: O4,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    DynamicEnqueueTPUEmbeddingArbitraryTensorBatch::new().build(
        sample_indices_or_row_splits,
        embedding_indices,
        aggregation_weights,
        mode_override,
        device_ordinal,
        scope,
    )
}

/// Builder for the `DynamicPartition` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct DynamicPartition {
    num_partitions: ::std::option::Option<i64>,
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'DynamicPartition' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct DynamicPartitionInst {
    /// An instance of a fully built DynamicPartition Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl DynamicPartition {
    /// Creates a new `DynamicPartition`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `num_partitions` attribute.
    pub fn num_partitions<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.num_partitions = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `DynamicPartition` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        data: O0,
        partitions: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(data.into(), partitions.into(), scope)
    }
    fn build_impl(
        &self,
        data: crate::Output,
        partitions: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("DynamicPartition", |nd| {
            nd.add_input(data);
            nd.add_input(partitions);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.num_partitions {
                nd.set_attr_int("num_partitions", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'DynamicPartition' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        data: crate::Output,
        partitions: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<DynamicPartitionInst> {
        let op = scope.new_operation("DynamicPartition", |builder| {
            builder.add_input(data);
            builder.add_input(partitions);
            if let ::std::option::Option::Some(value) = &self.num_partitions {
                builder.set_attr_int("num_partitions", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(DynamicPartitionInst { op })
    }
}
impl DynamicPartitionInst {
    /// Returns a Vector of outputs for 'outputs' Output of this DynamicPartition operation.
    pub fn outputs(&self) -> crate::Result<Vec<crate::Output>> {
        let mut Outputs = vec![];
        for i in 0..self.op.get_attr_int("num_partitions")? as i32 {
            Outputs.push(crate::Output {
                operation: self.op.clone(),
                index: i,
            });
        }
        Ok(Outputs)
    }
    /// Returns the 'data' Input of this 'DynamicPartition' operation.
    pub fn data(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'partitions' Input of this 'DynamicPartition' operation.
    pub fn partitions(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<DynamicPartitionInst> for crate::Operation {
    fn from(inst: DynamicPartitionInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `DynamicPartition::new().build(data, partitions, scope)`.
pub fn dynamic_partition<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    data: O0,
    partitions: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    DynamicPartition::new().build(data, partitions, scope)
}

/// Builder for the `DynamicStitch` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct DynamicStitch {
    N: ::std::option::Option<i64>,
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'DynamicStitch' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct DynamicStitchInst {
    /// An instance of a fully built DynamicStitch Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl DynamicStitch {
    /// Creates a new `DynamicStitch`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `N` attribute.
    pub fn N<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.N = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `DynamicStitch` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        indices: O0,
        data: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(indices.into(), data.into(), scope)
    }
    fn build_impl(
        &self,
        indices: crate::Output,
        data: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("DynamicStitch", |nd| {
            nd.add_input(indices);
            nd.add_input(data);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.N {
                nd.set_attr_int("N", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'DynamicStitch' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        indices: Vec<crate::Output>,
        data: Vec<crate::Output>,
        scope: &mut crate::Scope,
    ) -> crate::Result<DynamicStitchInst> {
        let op = scope.new_operation("DynamicStitch", |builder| {
            builder.add_input_list(&indices);
            builder.add_input_list(&data);
            builder.set_attr_int("N", indices.clone().len() as i64)?;
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(DynamicStitchInst { op })
    }
}
impl DynamicStitchInst {
    /// Returns the 'merged' Output of this 'DynamicStitch' operation.
    pub fn merged(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns a Vector of indices for 'indices' Input of this DynamicStitch operation.
    pub fn indices(&self) -> crate::Result<Vec<crate::Input>> {
        let mut Inputs = vec![];
        for i in 0..self.op.get_attr_int("N")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
    /// Returns a Vector of data for 'data' Input of this DynamicStitch operation.
    pub fn data(&self) -> crate::Result<Vec<crate::Input>> {
        let dynamic_offset = (self.op.get_attr_int("N")? + 1) as i32;
        let mut Inputs = vec![];
        for i in dynamic_offset..dynamic_offset + self.op.get_attr_int("N")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
}
impl From<DynamicStitchInst> for crate::Operation {
    fn from(inst: DynamicStitchInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `DynamicStitch::new().build(indices, data, scope)`.
pub fn dynamic_stitch<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    indices: O0,
    data: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    DynamicStitch::new().build(indices, data, scope)
}

/// Builder for the `EagerPyFunc` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct EagerPyFunc {
    token: ::std::option::Option<::std::string::String>,
    is_async: ::std::option::Option<bool>,
    Tin: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    Tout: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'EagerPyFunc' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct EagerPyFuncInst {
    /// An instance of a fully built EagerPyFunc Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl EagerPyFunc {
    /// Creates a new `EagerPyFunc`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `token` attribute.
    pub fn token<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.token = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `is_async` attribute.
    pub fn is_async<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.is_async = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tin` attribute.
    pub fn Tin<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tin = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tout` attribute.
    pub fn Tout<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tout = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `EagerPyFunc` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("EagerPyFunc", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.token {
                nd.set_attr_string("token", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.is_async {
                nd.set_attr_bool("is_async", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tin {
                nd.set_attr_type_list("Tin", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tout {
                nd.set_attr_type_list("Tout", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'EagerPyFunc' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<EagerPyFuncInst> {
        let op = scope.new_operation("EagerPyFunc", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.token {
                builder.set_attr_string("token", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.is_async {
                builder.set_attr_bool("is_async", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tin {
                builder.set_attr_type_list("Tin", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tout {
                builder.set_attr_type_list("Tout", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(EagerPyFuncInst { op })
    }
}
impl EagerPyFuncInst {
    /// Returns the 'output' Output of this 'EagerPyFunc' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'EagerPyFunc' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<EagerPyFuncInst> for crate::Operation {
    fn from(inst: EagerPyFuncInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `EagerPyFunc::new().build(input, scope)`.
pub fn eager_py_func<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    EagerPyFunc::new().build(input, scope)
}

/// Builder for the `EditDistance` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct EditDistance {
    normalize: ::std::option::Option<bool>,
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'EditDistance' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct EditDistanceInst {
    /// An instance of a fully built EditDistance Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl EditDistance {
    /// Creates a new `EditDistance`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `normalize` attribute.
    pub fn normalize<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.normalize = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `EditDistance` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
    >(
        &self,
        hypothesis_indices: O0,
        hypothesis_values: O1,
        hypothesis_shape: O2,
        truth_indices: O3,
        truth_values: O4,
        truth_shape: O5,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            hypothesis_indices.into(),
            hypothesis_values.into(),
            hypothesis_shape.into(),
            truth_indices.into(),
            truth_values.into(),
            truth_shape.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        hypothesis_indices: crate::Output,
        hypothesis_values: crate::Output,
        hypothesis_shape: crate::Output,
        truth_indices: crate::Output,
        truth_values: crate::Output,
        truth_shape: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("EditDistance", |nd| {
            nd.add_input(hypothesis_indices);
            nd.add_input(hypothesis_values);
            nd.add_input(hypothesis_shape);
            nd.add_input(truth_indices);
            nd.add_input(truth_values);
            nd.add_input(truth_shape);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.normalize {
                nd.set_attr_bool("normalize", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'EditDistance' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        hypothesis_indices: crate::Output,
        hypothesis_values: crate::Output,
        hypothesis_shape: crate::Output,
        truth_indices: crate::Output,
        truth_values: crate::Output,
        truth_shape: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<EditDistanceInst> {
        let op = scope.new_operation("EditDistance", |builder| {
            builder.add_input(hypothesis_indices);
            builder.add_input(hypothesis_values);
            builder.add_input(hypothesis_shape);
            builder.add_input(truth_indices);
            builder.add_input(truth_values);
            builder.add_input(truth_shape);
            if let ::std::option::Option::Some(value) = &self.normalize {
                builder.set_attr_bool("normalize", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(EditDistanceInst { op })
    }
}
impl EditDistanceInst {
    /// Returns the 'output' Output of this 'EditDistance' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'hypothesis_indices' Input of this 'EditDistance' operation.
    pub fn hypothesis_indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'hypothesis_values' Input of this 'EditDistance' operation.
    pub fn hypothesis_values(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'hypothesis_shape' Input of this 'EditDistance' operation.
    pub fn hypothesis_shape(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'truth_indices' Input of this 'EditDistance' operation.
    pub fn truth_indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'truth_values' Input of this 'EditDistance' operation.
    pub fn truth_values(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
    /// Returns the 'truth_shape' Input of this 'EditDistance' operation.
    pub fn truth_shape(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 5,
        }
    }
}
impl From<EditDistanceInst> for crate::Operation {
    fn from(inst: EditDistanceInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `EditDistance::new().build(hypothesis_indices, hypothesis_values, hypothesis_shape, truth_indices, truth_values, truth_shape, scope)`.
pub fn edit_distance<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
>(
    hypothesis_indices: O0,
    hypothesis_values: O1,
    hypothesis_shape: O2,
    truth_indices: O3,
    truth_values: O4,
    truth_shape: O5,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    EditDistance::new().build(
        hypothesis_indices,
        hypothesis_values,
        hypothesis_shape,
        truth_indices,
        truth_values,
        truth_shape,
        scope,
    )
}

/// Builder for the `Eig` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Eig {
    compute_v: ::std::option::Option<bool>,
    T: ::std::option::Option<crate::DataType>,
    Tout: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Eig' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct EigInst {
    /// An instance of a fully built Eig Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Eig {
    /// Creates a new `Eig`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `compute_v` attribute.
    pub fn compute_v<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.compute_v = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tout` attribute.
    pub fn Tout<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Tout = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Eig` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Eig", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.compute_v {
                nd.set_attr_bool("compute_v", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tout {
                nd.set_attr_type("Tout", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Eig' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<EigInst> {
        let op = scope.new_operation("Eig", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.compute_v {
                builder.set_attr_bool("compute_v", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tout {
                builder.set_attr_type("Tout", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(EigInst { op })
    }
}
impl EigInst {
    /// Returns the 'e' Output of this 'Eig' operation.
    pub fn e(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'v' Output of this 'Eig' operation.
    pub fn v(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'input' Input of this 'Eig' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<EigInst> for crate::Operation {
    fn from(inst: EigInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Eig::new().build(input, scope)`.
pub fn eig<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Eig::new().build(input, scope)
}

/// Builder for the `Einsum` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Einsum {
    equation: ::std::option::Option<::std::string::String>,
    N: ::std::option::Option<i64>,
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Einsum' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct EinsumInst {
    /// An instance of a fully built Einsum Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Einsum {
    /// Creates a new `Einsum`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `equation` attribute.
    pub fn equation<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.equation = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `N` attribute.
    pub fn N<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.N = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Einsum` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        inputs: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(inputs.into(), scope)
    }
    fn build_impl(
        &self,
        inputs: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Einsum", |nd| {
            nd.add_input(inputs);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.equation {
                nd.set_attr_string("equation", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.N {
                nd.set_attr_int("N", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Einsum' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        inputs: Vec<crate::Output>,
        scope: &mut crate::Scope,
    ) -> crate::Result<EinsumInst> {
        let op = scope.new_operation("Einsum", |builder| {
            builder.add_input_list(&inputs);
            if let ::std::option::Option::Some(value) = &self.equation {
                builder.set_attr_string("equation", value)?;
            }
            builder.set_attr_int("N", inputs.clone().len() as i64)?;
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(EinsumInst { op })
    }
}
impl EinsumInst {
    /// Returns the 'output' Output of this 'Einsum' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns a Vector of inputs for 'inputs' Input of this Einsum operation.
    pub fn inputs(&self) -> crate::Result<Vec<crate::Input>> {
        let mut Inputs = vec![];
        for i in 0..self.op.get_attr_int("N")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
}
impl From<EinsumInst> for crate::Operation {
    fn from(inst: EinsumInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Einsum::new().build(inputs, scope)`.
pub fn einsum<O0: ::std::convert::Into<crate::Output>>(
    inputs: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Einsum::new().build(inputs, scope)
}

/// Builder for the `Elu` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Elu {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Elu' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct EluInst {
    /// An instance of a fully built Elu Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Elu {
    /// Creates a new `Elu`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Elu` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        features: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(features.into(), scope)
    }
    fn build_impl(
        &self,
        features: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Elu", |nd| {
            nd.add_input(features);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Elu' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        features: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<EluInst> {
        let op = scope.new_operation("Elu", |builder| {
            builder.add_input(features);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(EluInst { op })
    }
}
impl EluInst {
    /// Returns the 'activations' Output of this 'Elu' operation.
    pub fn activations(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'features' Input of this 'Elu' operation.
    pub fn features(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<EluInst> for crate::Operation {
    fn from(inst: EluInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Elu::new().build(features, scope)`.
pub fn elu<O0: ::std::convert::Into<crate::Output>>(
    features: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Elu::new().build(features, scope)
}

/// Builder for the `EluGrad` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct EluGrad {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'EluGrad' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct EluGradInst {
    /// An instance of a fully built EluGrad Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl EluGrad {
    /// Creates a new `EluGrad`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `EluGrad` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        gradients: O0,
        outputs: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(gradients.into(), outputs.into(), scope)
    }
    fn build_impl(
        &self,
        gradients: crate::Output,
        outputs: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("EluGrad", |nd| {
            nd.add_input(gradients);
            nd.add_input(outputs);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'EluGrad' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        gradients: crate::Output,
        outputs: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<EluGradInst> {
        let op = scope.new_operation("EluGrad", |builder| {
            builder.add_input(gradients);
            builder.add_input(outputs);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(EluGradInst { op })
    }
}
impl EluGradInst {
    /// Returns the 'backprops' Output of this 'EluGrad' operation.
    pub fn backprops(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'gradients' Input of this 'EluGrad' operation.
    pub fn gradients(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'outputs' Input of this 'EluGrad' operation.
    pub fn outputs(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<EluGradInst> for crate::Operation {
    fn from(inst: EluGradInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `EluGrad::new().build(gradients, outputs, scope)`.
pub fn elu_grad<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    gradients: O0,
    outputs: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    EluGrad::new().build(gradients, outputs, scope)
}

/// Builder for the `Empty` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Empty {
    dtype: ::std::option::Option<crate::DataType>,
    init: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Empty' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct EmptyInst {
    /// An instance of a fully built Empty Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Empty {
    /// Creates a new `Empty`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `dtype` attribute.
    pub fn dtype<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `init` attribute.
    pub fn init<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.init = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Empty` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        shape: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(shape.into(), scope)
    }
    fn build_impl(
        &self,
        shape: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Empty", |nd| {
            nd.add_input(shape);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                nd.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.init {
                nd.set_attr_bool("init", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Empty' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        shape: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<EmptyInst> {
        let op = scope.new_operation("Empty", |builder| {
            builder.add_input(shape);
            if let ::std::option::Option::Some(value) = &self.dtype {
                builder.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.init {
                builder.set_attr_bool("init", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(EmptyInst { op })
    }
}
impl EmptyInst {
    /// Returns the 'output' Output of this 'Empty' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'shape' Input of this 'Empty' operation.
    pub fn shape(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<EmptyInst> for crate::Operation {
    fn from(inst: EmptyInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Empty::new().build(shape, scope)`.
pub fn empty<O0: ::std::convert::Into<crate::Output>>(
    shape: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Empty::new().build(shape, scope)
}

/// Builder for the `EmptyTensorList` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct EmptyTensorList {
    element_dtype: ::std::option::Option<crate::DataType>,
    shape_type: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'EmptyTensorList' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct EmptyTensorListInst {
    /// An instance of a fully built EmptyTensorList Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl EmptyTensorList {
    /// Creates a new `EmptyTensorList`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `element_dtype` attribute.
    pub fn element_dtype<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.element_dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shape_type` attribute.
    pub fn shape_type<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.shape_type = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `EmptyTensorList` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        element_shape: O0,
        max_num_elements: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(element_shape.into(), max_num_elements.into(), scope)
    }
    fn build_impl(
        &self,
        element_shape: crate::Output,
        max_num_elements: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("EmptyTensorList", |nd| {
            nd.add_input(element_shape);
            nd.add_input(max_num_elements);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.element_dtype {
                nd.set_attr_type("element_dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shape_type {
                nd.set_attr_type("shape_type", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'EmptyTensorList' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        element_shape: crate::Output,
        max_num_elements: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<EmptyTensorListInst> {
        let op = scope.new_operation("EmptyTensorList", |builder| {
            builder.add_input(element_shape);
            builder.add_input(max_num_elements);
            if let ::std::option::Option::Some(value) = &self.element_dtype {
                builder.set_attr_type("element_dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shape_type {
                builder.set_attr_type("shape_type", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(EmptyTensorListInst { op })
    }
}
impl EmptyTensorListInst {
    /// Returns the 'handle' Output of this 'EmptyTensorList' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'element_shape' Input of this 'EmptyTensorList' operation.
    pub fn element_shape(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'max_num_elements' Input of this 'EmptyTensorList' operation.
    pub fn max_num_elements(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<EmptyTensorListInst> for crate::Operation {
    fn from(inst: EmptyTensorListInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `EmptyTensorList::new().build(element_shape, max_num_elements, scope)`.
pub fn empty_tensor_list<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    element_shape: O0,
    max_num_elements: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    EmptyTensorList::new().build(element_shape, max_num_elements, scope)
}

/// Builder for the `EmptyTensorMap` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct EmptyTensorMap {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'EmptyTensorMap' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct EmptyTensorMapInst {
    /// An instance of a fully built EmptyTensorMap Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl EmptyTensorMap {
    /// Creates a new `EmptyTensorMap`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `EmptyTensorMap` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("EmptyTensorMap", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'EmptyTensorMap' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(&self, scope: &mut crate::Scope) -> crate::Result<EmptyTensorMapInst> {
        let op = scope.new_operation("EmptyTensorMap", |builder| ::std::result::Result::Ok(()))?;
        Ok(EmptyTensorMapInst { op })
    }
}
impl EmptyTensorMapInst {
    /// Returns the 'handle' Output of this 'EmptyTensorMap' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
}
impl From<EmptyTensorMapInst> for crate::Operation {
    fn from(inst: EmptyTensorMapInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `EmptyTensorMap::new().build(scope)`.
pub fn empty_tensor_map(scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
    EmptyTensorMap::new().build(scope)
}

/// Builder for the `EncodeBase64` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct EncodeBase64 {
    pad: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'EncodeBase64' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct EncodeBase64Inst {
    /// An instance of a fully built EncodeBase64 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl EncodeBase64 {
    /// Creates a new `EncodeBase64`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `pad` attribute.
    pub fn pad<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.pad = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `EncodeBase64` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("EncodeBase64", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.pad {
                nd.set_attr_bool("pad", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'EncodeBase64' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<EncodeBase64Inst> {
        let op = scope.new_operation("EncodeBase64", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.pad {
                builder.set_attr_bool("pad", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(EncodeBase64Inst { op })
    }
}
impl EncodeBase64Inst {
    /// Returns the 'output' Output of this 'EncodeBase64' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'EncodeBase64' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<EncodeBase64Inst> for crate::Operation {
    fn from(inst: EncodeBase64Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `EncodeBase64::new().build(input, scope)`.
pub fn encode_base64<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    EncodeBase64::new().build(input, scope)
}

/// Builder for the `EncodeJpeg` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct EncodeJpeg {
    format: ::std::option::Option<::std::string::String>,
    quality: ::std::option::Option<i64>,
    progressive: ::std::option::Option<bool>,
    optimize_size: ::std::option::Option<bool>,
    chroma_downsampling: ::std::option::Option<bool>,
    density_unit: ::std::option::Option<::std::string::String>,
    x_density: ::std::option::Option<i64>,
    y_density: ::std::option::Option<i64>,
    xmp_metadata: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'EncodeJpeg' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct EncodeJpegInst {
    /// An instance of a fully built EncodeJpeg Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl EncodeJpeg {
    /// Creates a new `EncodeJpeg`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `format` attribute.
    pub fn format<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.format = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `quality` attribute.
    pub fn quality<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.quality = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `progressive` attribute.
    pub fn progressive<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.progressive = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `optimize_size` attribute.
    pub fn optimize_size<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.optimize_size = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `chroma_downsampling` attribute.
    pub fn chroma_downsampling<ArgType: ::std::convert::Into<bool>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.chroma_downsampling = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `density_unit` attribute.
    pub fn density_unit<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.density_unit = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `x_density` attribute.
    pub fn x_density<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.x_density = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `y_density` attribute.
    pub fn y_density<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.y_density = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `xmp_metadata` attribute.
    pub fn xmp_metadata<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.xmp_metadata = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `EncodeJpeg` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        image: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(image.into(), scope)
    }
    fn build_impl(
        &self,
        image: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("EncodeJpeg", |nd| {
            nd.add_input(image);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.format {
                nd.set_attr_string("format", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.quality {
                nd.set_attr_int("quality", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.progressive {
                nd.set_attr_bool("progressive", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.optimize_size {
                nd.set_attr_bool("optimize_size", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.chroma_downsampling {
                nd.set_attr_bool("chroma_downsampling", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.density_unit {
                nd.set_attr_string("density_unit", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.x_density {
                nd.set_attr_int("x_density", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.y_density {
                nd.set_attr_int("y_density", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.xmp_metadata {
                nd.set_attr_string("xmp_metadata", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'EncodeJpeg' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        image: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<EncodeJpegInst> {
        let op = scope.new_operation("EncodeJpeg", |builder| {
            builder.add_input(image);
            if let ::std::option::Option::Some(value) = &self.format {
                builder.set_attr_string("format", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.quality {
                builder.set_attr_int("quality", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.progressive {
                builder.set_attr_bool("progressive", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.optimize_size {
                builder.set_attr_bool("optimize_size", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.chroma_downsampling {
                builder.set_attr_bool("chroma_downsampling", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.density_unit {
                builder.set_attr_string("density_unit", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.x_density {
                builder.set_attr_int("x_density", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.y_density {
                builder.set_attr_int("y_density", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.xmp_metadata {
                builder.set_attr_string("xmp_metadata", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(EncodeJpegInst { op })
    }
}
impl EncodeJpegInst {
    /// Returns the 'contents' Output of this 'EncodeJpeg' operation.
    pub fn contents(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'image' Input of this 'EncodeJpeg' operation.
    pub fn image(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<EncodeJpegInst> for crate::Operation {
    fn from(inst: EncodeJpegInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `EncodeJpeg::new().build(image, scope)`.
pub fn encode_jpeg<O0: ::std::convert::Into<crate::Output>>(
    image: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    EncodeJpeg::new().build(image, scope)
}

/// Builder for the `EncodeJpegVariableQuality` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct EncodeJpegVariableQuality {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'EncodeJpegVariableQuality' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct EncodeJpegVariableQualityInst {
    /// An instance of a fully built EncodeJpegVariableQuality Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl EncodeJpegVariableQuality {
    /// Creates a new `EncodeJpegVariableQuality`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `EncodeJpegVariableQuality` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        images: O0,
        quality: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(images.into(), quality.into(), scope)
    }
    fn build_impl(
        &self,
        images: crate::Output,
        quality: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("EncodeJpegVariableQuality", |nd| {
            nd.add_input(images);
            nd.add_input(quality);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'EncodeJpegVariableQuality' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        images: crate::Output,
        quality: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<EncodeJpegVariableQualityInst> {
        let op = scope.new_operation("EncodeJpegVariableQuality", |builder| {
            builder.add_input(images);
            builder.add_input(quality);
            ::std::result::Result::Ok(())
        })?;
        Ok(EncodeJpegVariableQualityInst { op })
    }
}
impl EncodeJpegVariableQualityInst {
    /// Returns the 'contents' Output of this 'EncodeJpegVariableQuality' operation.
    pub fn contents(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'images' Input of this 'EncodeJpegVariableQuality' operation.
    pub fn images(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'quality' Input of this 'EncodeJpegVariableQuality' operation.
    pub fn quality(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<EncodeJpegVariableQualityInst> for crate::Operation {
    fn from(inst: EncodeJpegVariableQualityInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `EncodeJpegVariableQuality::new().build(images, quality, scope)`.
pub fn encode_jpeg_variable_quality<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    images: O0,
    quality: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    EncodeJpegVariableQuality::new().build(images, quality, scope)
}

/// Builder for the `EncodePng` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct EncodePng {
    compression: ::std::option::Option<i64>,
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'EncodePng' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct EncodePngInst {
    /// An instance of a fully built EncodePng Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl EncodePng {
    /// Creates a new `EncodePng`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `compression` attribute.
    pub fn compression<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.compression = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `EncodePng` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        image: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(image.into(), scope)
    }
    fn build_impl(
        &self,
        image: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("EncodePng", |nd| {
            nd.add_input(image);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.compression {
                nd.set_attr_int("compression", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'EncodePng' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        image: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<EncodePngInst> {
        let op = scope.new_operation("EncodePng", |builder| {
            builder.add_input(image);
            if let ::std::option::Option::Some(value) = &self.compression {
                builder.set_attr_int("compression", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(EncodePngInst { op })
    }
}
impl EncodePngInst {
    /// Returns the 'contents' Output of this 'EncodePng' operation.
    pub fn contents(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'image' Input of this 'EncodePng' operation.
    pub fn image(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<EncodePngInst> for crate::Operation {
    fn from(inst: EncodePngInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `EncodePng::new().build(image, scope)`.
pub fn encode_png<O0: ::std::convert::Into<crate::Output>>(
    image: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    EncodePng::new().build(image, scope)
}

/// Builder for the `EncodeProto` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct EncodeProto {
    field_names: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
    message_type: ::std::option::Option<::std::string::String>,
    descriptor_source: ::std::option::Option<::std::string::String>,
    Tinput_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'EncodeProto' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct EncodeProtoInst {
    /// An instance of a fully built EncodeProto Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl EncodeProto {
    /// Creates a new `EncodeProto`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `field_names` attribute.
    pub fn field_names<ArgType: ::std::convert::Into<::std::vec::Vec<::std::string::String>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.field_names = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `message_type` attribute.
    pub fn message_type<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.message_type = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `descriptor_source` attribute.
    pub fn descriptor_source<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.descriptor_source = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tinput_types` attribute.
    pub fn Tinput_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tinput_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `EncodeProto` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        sizes: O0,
        values: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(sizes.into(), values.into(), scope)
    }
    fn build_impl(
        &self,
        sizes: crate::Output,
        values: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("EncodeProto", |nd| {
            nd.add_input(sizes);
            nd.add_input(values);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.field_names {
                nd.set_attr_string_list("field_names", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.message_type {
                nd.set_attr_string("message_type", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.descriptor_source {
                nd.set_attr_string("descriptor_source", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tinput_types {
                nd.set_attr_type_list("Tinput_types", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'EncodeProto' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        sizes: crate::Output,
        values: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<EncodeProtoInst> {
        let op = scope.new_operation("EncodeProto", |builder| {
            builder.add_input(sizes);
            builder.add_input(values);
            if let ::std::option::Option::Some(value) = &self.field_names {
                builder.set_attr_string_list("field_names", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.message_type {
                builder.set_attr_string("message_type", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.descriptor_source {
                builder.set_attr_string("descriptor_source", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tinput_types {
                builder.set_attr_type_list("Tinput_types", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(EncodeProtoInst { op })
    }
}
impl EncodeProtoInst {
    /// Returns the 'bytes' Output of this 'EncodeProto' operation.
    pub fn bytes(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'sizes' Input of this 'EncodeProto' operation.
    pub fn sizes(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'values' Input of this 'EncodeProto' operation.
    pub fn values(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<EncodeProtoInst> for crate::Operation {
    fn from(inst: EncodeProtoInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `EncodeProto::new().build(sizes, values, scope)`.
pub fn encode_proto<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    sizes: O0,
    values: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    EncodeProto::new().build(sizes, values, scope)
}

/// Builder for the `EncodeWav` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct EncodeWav {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'EncodeWav' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct EncodeWavInst {
    /// An instance of a fully built EncodeWav Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl EncodeWav {
    /// Creates a new `EncodeWav`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `EncodeWav` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        audio: O0,
        sample_rate: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(audio.into(), sample_rate.into(), scope)
    }
    fn build_impl(
        &self,
        audio: crate::Output,
        sample_rate: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("EncodeWav", |nd| {
            nd.add_input(audio);
            nd.add_input(sample_rate);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'EncodeWav' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        audio: crate::Output,
        sample_rate: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<EncodeWavInst> {
        let op = scope.new_operation("EncodeWav", |builder| {
            builder.add_input(audio);
            builder.add_input(sample_rate);
            ::std::result::Result::Ok(())
        })?;
        Ok(EncodeWavInst { op })
    }
}
impl EncodeWavInst {
    /// Returns the 'contents' Output of this 'EncodeWav' operation.
    pub fn contents(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'audio' Input of this 'EncodeWav' operation.
    pub fn audio(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'sample_rate' Input of this 'EncodeWav' operation.
    pub fn sample_rate(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<EncodeWavInst> for crate::Operation {
    fn from(inst: EncodeWavInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `EncodeWav::new().build(audio, sample_rate, scope)`.
pub fn encode_wav<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    audio: O0,
    sample_rate: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    EncodeWav::new().build(audio, sample_rate, scope)
}

/// Builder for the `EnqueueTPUEmbeddingArbitraryTensorBatch` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct EnqueueTPUEmbeddingArbitraryTensorBatch {
    T1: ::std::option::Option<crate::DataType>,
    T2: ::std::option::Option<crate::DataType>,
    T3: ::std::option::Option<crate::DataType>,
    N: ::std::option::Option<i64>,
    device_ordinal: ::std::option::Option<i64>,
    combiners: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'EnqueueTPUEmbeddingArbitraryTensorBatch' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct EnqueueTPUEmbeddingArbitraryTensorBatchInst {
    /// An instance of a fully built EnqueueTPUEmbeddingArbitraryTensorBatch Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl EnqueueTPUEmbeddingArbitraryTensorBatch {
    /// Creates a new `EnqueueTPUEmbeddingArbitraryTensorBatch`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T1` attribute.
    pub fn T1<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T1 = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T2` attribute.
    pub fn T2<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T2 = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T3` attribute.
    pub fn T3<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T3 = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `N` attribute.
    pub fn N<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.N = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `device_ordinal` attribute.
    pub fn device_ordinal<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.device_ordinal = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `combiners` attribute.
    pub fn combiners<ArgType: ::std::convert::Into<::std::vec::Vec<::std::string::String>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.combiners = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `EnqueueTPUEmbeddingArbitraryTensorBatch` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
    >(
        &self,
        sample_indices_or_row_splits: O0,
        embedding_indices: O1,
        aggregation_weights: O2,
        mode_override: O3,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            sample_indices_or_row_splits.into(),
            embedding_indices.into(),
            aggregation_weights.into(),
            mode_override.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        sample_indices_or_row_splits: crate::Output,
        embedding_indices: crate::Output,
        aggregation_weights: crate::Output,
        mode_override: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("EnqueueTPUEmbeddingArbitraryTensorBatch", |nd| {
            nd.add_input(sample_indices_or_row_splits);
            nd.add_input(embedding_indices);
            nd.add_input(aggregation_weights);
            nd.add_input(mode_override);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T1 {
                nd.set_attr_type("T1", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T2 {
                nd.set_attr_type("T2", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T3 {
                nd.set_attr_type("T3", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.N {
                nd.set_attr_int("N", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.device_ordinal {
                nd.set_attr_int("device_ordinal", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.combiners {
                nd.set_attr_string_list("combiners", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'EnqueueTPUEmbeddingArbitraryTensorBatch' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        sample_indices_or_row_splits: Vec<crate::Output>,
        embedding_indices: Vec<crate::Output>,
        aggregation_weights: Vec<crate::Output>,
        mode_override: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<EnqueueTPUEmbeddingArbitraryTensorBatchInst> {
        let op = scope.new_operation("EnqueueTPUEmbeddingArbitraryTensorBatch", |builder| {
            builder.add_input_list(&sample_indices_or_row_splits);
            builder.add_input_list(&embedding_indices);
            builder.add_input_list(&aggregation_weights);
            builder.add_input(mode_override);
            if let ::std::option::Option::Some(value) = &self.T1 {
                builder.set_attr_type("T1", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T2 {
                builder.set_attr_type("T2", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T3 {
                builder.set_attr_type("T3", *value)?;
            }
            builder.set_attr_int("N", sample_indices_or_row_splits.clone().len() as i64)?;
            if let ::std::option::Option::Some(value) = &self.device_ordinal {
                builder.set_attr_int("device_ordinal", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.combiners {
                builder.set_attr_string_list("combiners", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(EnqueueTPUEmbeddingArbitraryTensorBatchInst { op })
    }
}
impl EnqueueTPUEmbeddingArbitraryTensorBatchInst {
    /// Returns a Vector of sample_indices_or_row_splits for 'sample_indices_or_row_splits' Input of this EnqueueTPUEmbeddingArbitraryTensorBatch operation.
    pub fn sample_indices_or_row_splits(&self) -> crate::Result<Vec<crate::Input>> {
        let mut Inputs = vec![];
        for i in 0..self.op.get_attr_int("N")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
    /// Returns a Vector of embedding_indices for 'embedding_indices' Input of this EnqueueTPUEmbeddingArbitraryTensorBatch operation.
    pub fn embedding_indices(&self) -> crate::Result<Vec<crate::Input>> {
        let dynamic_offset = (self.op.get_attr_int("N")? + 1) as i32;
        let mut Inputs = vec![];
        for i in dynamic_offset..dynamic_offset + self.op.get_attr_int("N")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
    /// Returns a Vector of aggregation_weights for 'aggregation_weights' Input of this EnqueueTPUEmbeddingArbitraryTensorBatch operation.
    pub fn aggregation_weights(&self) -> crate::Result<Vec<crate::Input>> {
        let dynamic_offset = (2 * self.op.get_attr_int("N")? + 2) as i32;
        let mut Inputs = vec![];
        for i in dynamic_offset..dynamic_offset + self.op.get_attr_int("N")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
    /// Returns the 'mode_override' Input of this 'EnqueueTPUEmbeddingArbitraryTensorBatch' operation.
    pub fn mode_override(&self) -> crate::Result<crate::Input> {
        let dynamic_offset = (3 * self.op.get_attr_int("N")? + 3) as i32;
        Ok(crate::Input {
            operation: &self.op,
            index: dynamic_offset,
        })
    }
}
impl From<EnqueueTPUEmbeddingArbitraryTensorBatchInst> for crate::Operation {
    fn from(inst: EnqueueTPUEmbeddingArbitraryTensorBatchInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `EnqueueTPUEmbeddingArbitraryTensorBatch::new().build(sample_indices_or_row_splits, embedding_indices, aggregation_weights, mode_override, scope)`.
pub fn enqueue_tpuembedding_arbitrary_tensor_batch<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
>(
    sample_indices_or_row_splits: O0,
    embedding_indices: O1,
    aggregation_weights: O2,
    mode_override: O3,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    EnqueueTPUEmbeddingArbitraryTensorBatch::new().build(
        sample_indices_or_row_splits,
        embedding_indices,
        aggregation_weights,
        mode_override,
        scope,
    )
}

/// Builder for the `EnqueueTPUEmbeddingBatch` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct EnqueueTPUEmbeddingBatch {
    N: ::std::option::Option<i64>,
    device_ordinal: ::std::option::Option<i64>,
    combiners: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'EnqueueTPUEmbeddingBatch' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct EnqueueTPUEmbeddingBatchInst {
    /// An instance of a fully built EnqueueTPUEmbeddingBatch Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl EnqueueTPUEmbeddingBatch {
    /// Creates a new `EnqueueTPUEmbeddingBatch`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `N` attribute.
    pub fn N<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.N = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `device_ordinal` attribute.
    pub fn device_ordinal<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.device_ordinal = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `combiners` attribute.
    pub fn combiners<ArgType: ::std::convert::Into<::std::vec::Vec<::std::string::String>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.combiners = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `EnqueueTPUEmbeddingBatch` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        batch: O0,
        mode_override: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(batch.into(), mode_override.into(), scope)
    }
    fn build_impl(
        &self,
        batch: crate::Output,
        mode_override: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("EnqueueTPUEmbeddingBatch", |nd| {
            nd.add_input(batch);
            nd.add_input(mode_override);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.N {
                nd.set_attr_int("N", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.device_ordinal {
                nd.set_attr_int("device_ordinal", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.combiners {
                nd.set_attr_string_list("combiners", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'EnqueueTPUEmbeddingBatch' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        batch: Vec<crate::Output>,
        mode_override: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<EnqueueTPUEmbeddingBatchInst> {
        let op = scope.new_operation("EnqueueTPUEmbeddingBatch", |builder| {
            builder.add_input_list(&batch);
            builder.add_input(mode_override);
            builder.set_attr_int("N", batch.clone().len() as i64)?;
            if let ::std::option::Option::Some(value) = &self.device_ordinal {
                builder.set_attr_int("device_ordinal", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.combiners {
                builder.set_attr_string_list("combiners", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(EnqueueTPUEmbeddingBatchInst { op })
    }
}
impl EnqueueTPUEmbeddingBatchInst {
    /// Returns a Vector of batch for 'batch' Input of this EnqueueTPUEmbeddingBatch operation.
    pub fn batch(&self) -> crate::Result<Vec<crate::Input>> {
        let mut Inputs = vec![];
        for i in 0..self.op.get_attr_int("N")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
    /// Returns the 'mode_override' Input of this 'EnqueueTPUEmbeddingBatch' operation.
    pub fn mode_override(&self) -> crate::Result<crate::Input> {
        let dynamic_offset = (self.op.get_attr_int("N")? + 1) as i32;
        Ok(crate::Input {
            operation: &self.op,
            index: dynamic_offset,
        })
    }
}
impl From<EnqueueTPUEmbeddingBatchInst> for crate::Operation {
    fn from(inst: EnqueueTPUEmbeddingBatchInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `EnqueueTPUEmbeddingBatch::new().build(batch, mode_override, scope)`.
pub fn enqueue_tpuembedding_batch<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    batch: O0,
    mode_override: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    EnqueueTPUEmbeddingBatch::new().build(batch, mode_override, scope)
}

/// Builder for the `EnqueueTPUEmbeddingIntegerBatch` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct EnqueueTPUEmbeddingIntegerBatch {
    N: ::std::option::Option<i64>,
    device_ordinal: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'EnqueueTPUEmbeddingIntegerBatch' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct EnqueueTPUEmbeddingIntegerBatchInst {
    /// An instance of a fully built EnqueueTPUEmbeddingIntegerBatch Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl EnqueueTPUEmbeddingIntegerBatch {
    /// Creates a new `EnqueueTPUEmbeddingIntegerBatch`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `N` attribute.
    pub fn N<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.N = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `device_ordinal` attribute.
    pub fn device_ordinal<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.device_ordinal = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `EnqueueTPUEmbeddingIntegerBatch` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        batch: O0,
        mode_override: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(batch.into(), mode_override.into(), scope)
    }
    fn build_impl(
        &self,
        batch: crate::Output,
        mode_override: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("EnqueueTPUEmbeddingIntegerBatch", |nd| {
            nd.add_input(batch);
            nd.add_input(mode_override);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.N {
                nd.set_attr_int("N", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.device_ordinal {
                nd.set_attr_int("device_ordinal", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'EnqueueTPUEmbeddingIntegerBatch' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        batch: Vec<crate::Output>,
        mode_override: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<EnqueueTPUEmbeddingIntegerBatchInst> {
        let op = scope.new_operation("EnqueueTPUEmbeddingIntegerBatch", |builder| {
            builder.add_input_list(&batch);
            builder.add_input(mode_override);
            builder.set_attr_int("N", batch.clone().len() as i64)?;
            if let ::std::option::Option::Some(value) = &self.device_ordinal {
                builder.set_attr_int("device_ordinal", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(EnqueueTPUEmbeddingIntegerBatchInst { op })
    }
}
impl EnqueueTPUEmbeddingIntegerBatchInst {
    /// Returns a Vector of batch for 'batch' Input of this EnqueueTPUEmbeddingIntegerBatch operation.
    pub fn batch(&self) -> crate::Result<Vec<crate::Input>> {
        let mut Inputs = vec![];
        for i in 0..self.op.get_attr_int("N")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
    /// Returns the 'mode_override' Input of this 'EnqueueTPUEmbeddingIntegerBatch' operation.
    pub fn mode_override(&self) -> crate::Result<crate::Input> {
        let dynamic_offset = (self.op.get_attr_int("N")? + 1) as i32;
        Ok(crate::Input {
            operation: &self.op,
            index: dynamic_offset,
        })
    }
}
impl From<EnqueueTPUEmbeddingIntegerBatchInst> for crate::Operation {
    fn from(inst: EnqueueTPUEmbeddingIntegerBatchInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `EnqueueTPUEmbeddingIntegerBatch::new().build(batch, mode_override, scope)`.
pub fn enqueue_tpuembedding_integer_batch<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    batch: O0,
    mode_override: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    EnqueueTPUEmbeddingIntegerBatch::new().build(batch, mode_override, scope)
}

/// Builder for the `EnqueueTPUEmbeddingRaggedTensorBatch` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct EnqueueTPUEmbeddingRaggedTensorBatch {
    T1: ::std::option::Option<crate::DataType>,
    T2: ::std::option::Option<crate::DataType>,
    T3: ::std::option::Option<crate::DataType>,
    N: ::std::option::Option<i64>,
    device_ordinal: ::std::option::Option<i64>,
    combiners: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
    table_ids: ::std::option::Option<::std::vec::Vec<i64>>,
    max_sequence_lengths: ::std::option::Option<::std::vec::Vec<i64>>,
    num_features: ::std::option::Option<::std::vec::Vec<i64>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'EnqueueTPUEmbeddingRaggedTensorBatch' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct EnqueueTPUEmbeddingRaggedTensorBatchInst {
    /// An instance of a fully built EnqueueTPUEmbeddingRaggedTensorBatch Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl EnqueueTPUEmbeddingRaggedTensorBatch {
    /// Creates a new `EnqueueTPUEmbeddingRaggedTensorBatch`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T1` attribute.
    pub fn T1<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T1 = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T2` attribute.
    pub fn T2<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T2 = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T3` attribute.
    pub fn T3<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T3 = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `N` attribute.
    pub fn N<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.N = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `device_ordinal` attribute.
    pub fn device_ordinal<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.device_ordinal = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `combiners` attribute.
    pub fn combiners<ArgType: ::std::convert::Into<::std::vec::Vec<::std::string::String>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.combiners = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `table_ids` attribute.
    pub fn table_ids<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.table_ids = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `max_sequence_lengths` attribute.
    pub fn max_sequence_lengths<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.max_sequence_lengths = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `num_features` attribute.
    pub fn num_features<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.num_features = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `EnqueueTPUEmbeddingRaggedTensorBatch` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
    >(
        &self,
        sample_splits: O0,
        embedding_indices: O1,
        aggregation_weights: O2,
        mode_override: O3,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            sample_splits.into(),
            embedding_indices.into(),
            aggregation_weights.into(),
            mode_override.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        sample_splits: crate::Output,
        embedding_indices: crate::Output,
        aggregation_weights: crate::Output,
        mode_override: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("EnqueueTPUEmbeddingRaggedTensorBatch", |nd| {
            nd.add_input(sample_splits);
            nd.add_input(embedding_indices);
            nd.add_input(aggregation_weights);
            nd.add_input(mode_override);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T1 {
                nd.set_attr_type("T1", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T2 {
                nd.set_attr_type("T2", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T3 {
                nd.set_attr_type("T3", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.N {
                nd.set_attr_int("N", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.device_ordinal {
                nd.set_attr_int("device_ordinal", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.combiners {
                nd.set_attr_string_list("combiners", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.table_ids {
                nd.set_attr_int_list("table_ids", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.max_sequence_lengths {
                nd.set_attr_int_list("max_sequence_lengths", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_features {
                nd.set_attr_int_list("num_features", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'EnqueueTPUEmbeddingRaggedTensorBatch' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        sample_splits: Vec<crate::Output>,
        embedding_indices: Vec<crate::Output>,
        aggregation_weights: Vec<crate::Output>,
        mode_override: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<EnqueueTPUEmbeddingRaggedTensorBatchInst> {
        let op = scope.new_operation("EnqueueTPUEmbeddingRaggedTensorBatch", |builder| {
            builder.add_input_list(&sample_splits);
            builder.add_input_list(&embedding_indices);
            builder.add_input_list(&aggregation_weights);
            builder.add_input(mode_override);
            if let ::std::option::Option::Some(value) = &self.T1 {
                builder.set_attr_type("T1", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T2 {
                builder.set_attr_type("T2", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T3 {
                builder.set_attr_type("T3", *value)?;
            }
            builder.set_attr_int("N", sample_splits.clone().len() as i64)?;
            if let ::std::option::Option::Some(value) = &self.device_ordinal {
                builder.set_attr_int("device_ordinal", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.combiners {
                builder.set_attr_string_list("combiners", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.table_ids {
                builder.set_attr_int_list("table_ids", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.max_sequence_lengths {
                builder.set_attr_int_list("max_sequence_lengths", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_features {
                builder.set_attr_int_list("num_features", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(EnqueueTPUEmbeddingRaggedTensorBatchInst { op })
    }
}
impl EnqueueTPUEmbeddingRaggedTensorBatchInst {
    /// Returns a Vector of sample_splits for 'sample_splits' Input of this EnqueueTPUEmbeddingRaggedTensorBatch operation.
    pub fn sample_splits(&self) -> crate::Result<Vec<crate::Input>> {
        let mut Inputs = vec![];
        for i in 0..self.op.get_attr_int("N")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
    /// Returns a Vector of embedding_indices for 'embedding_indices' Input of this EnqueueTPUEmbeddingRaggedTensorBatch operation.
    pub fn embedding_indices(&self) -> crate::Result<Vec<crate::Input>> {
        let dynamic_offset = (self.op.get_attr_int("N")? + 1) as i32;
        let mut Inputs = vec![];
        for i in dynamic_offset..dynamic_offset + self.op.get_attr_int("N")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
    /// Returns a Vector of aggregation_weights for 'aggregation_weights' Input of this EnqueueTPUEmbeddingRaggedTensorBatch operation.
    pub fn aggregation_weights(&self) -> crate::Result<Vec<crate::Input>> {
        let dynamic_offset = (2 * self.op.get_attr_int("N")? + 2) as i32;
        let mut Inputs = vec![];
        for i in dynamic_offset..dynamic_offset + self.op.get_attr_int("N")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
    /// Returns the 'mode_override' Input of this 'EnqueueTPUEmbeddingRaggedTensorBatch' operation.
    pub fn mode_override(&self) -> crate::Result<crate::Input> {
        let dynamic_offset = (3 * self.op.get_attr_int("N")? + 3) as i32;
        Ok(crate::Input {
            operation: &self.op,
            index: dynamic_offset,
        })
    }
}
impl From<EnqueueTPUEmbeddingRaggedTensorBatchInst> for crate::Operation {
    fn from(inst: EnqueueTPUEmbeddingRaggedTensorBatchInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `EnqueueTPUEmbeddingRaggedTensorBatch::new().build(sample_splits, embedding_indices, aggregation_weights, mode_override, scope)`.
pub fn enqueue_tpuembedding_ragged_tensor_batch<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
>(
    sample_splits: O0,
    embedding_indices: O1,
    aggregation_weights: O2,
    mode_override: O3,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    EnqueueTPUEmbeddingRaggedTensorBatch::new().build(
        sample_splits,
        embedding_indices,
        aggregation_weights,
        mode_override,
        scope,
    )
}

/// Builder for the `EnqueueTPUEmbeddingSparseBatch` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct EnqueueTPUEmbeddingSparseBatch {
    T1: ::std::option::Option<crate::DataType>,
    T2: ::std::option::Option<crate::DataType>,
    T3: ::std::option::Option<crate::DataType>,
    N: ::std::option::Option<i64>,
    device_ordinal: ::std::option::Option<i64>,
    combiners: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'EnqueueTPUEmbeddingSparseBatch' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct EnqueueTPUEmbeddingSparseBatchInst {
    /// An instance of a fully built EnqueueTPUEmbeddingSparseBatch Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl EnqueueTPUEmbeddingSparseBatch {
    /// Creates a new `EnqueueTPUEmbeddingSparseBatch`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T1` attribute.
    pub fn T1<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T1 = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T2` attribute.
    pub fn T2<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T2 = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T3` attribute.
    pub fn T3<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T3 = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `N` attribute.
    pub fn N<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.N = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `device_ordinal` attribute.
    pub fn device_ordinal<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.device_ordinal = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `combiners` attribute.
    pub fn combiners<ArgType: ::std::convert::Into<::std::vec::Vec<::std::string::String>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.combiners = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `EnqueueTPUEmbeddingSparseBatch` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
    >(
        &self,
        sample_indices: O0,
        embedding_indices: O1,
        aggregation_weights: O2,
        mode_override: O3,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            sample_indices.into(),
            embedding_indices.into(),
            aggregation_weights.into(),
            mode_override.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        sample_indices: crate::Output,
        embedding_indices: crate::Output,
        aggregation_weights: crate::Output,
        mode_override: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("EnqueueTPUEmbeddingSparseBatch", |nd| {
            nd.add_input(sample_indices);
            nd.add_input(embedding_indices);
            nd.add_input(aggregation_weights);
            nd.add_input(mode_override);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T1 {
                nd.set_attr_type("T1", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T2 {
                nd.set_attr_type("T2", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T3 {
                nd.set_attr_type("T3", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.N {
                nd.set_attr_int("N", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.device_ordinal {
                nd.set_attr_int("device_ordinal", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.combiners {
                nd.set_attr_string_list("combiners", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'EnqueueTPUEmbeddingSparseBatch' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        sample_indices: Vec<crate::Output>,
        embedding_indices: Vec<crate::Output>,
        aggregation_weights: Vec<crate::Output>,
        mode_override: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<EnqueueTPUEmbeddingSparseBatchInst> {
        let op = scope.new_operation("EnqueueTPUEmbeddingSparseBatch", |builder| {
            builder.add_input_list(&sample_indices);
            builder.add_input_list(&embedding_indices);
            builder.add_input_list(&aggregation_weights);
            builder.add_input(mode_override);
            if let ::std::option::Option::Some(value) = &self.T1 {
                builder.set_attr_type("T1", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T2 {
                builder.set_attr_type("T2", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T3 {
                builder.set_attr_type("T3", *value)?;
            }
            builder.set_attr_int("N", sample_indices.clone().len() as i64)?;
            if let ::std::option::Option::Some(value) = &self.device_ordinal {
                builder.set_attr_int("device_ordinal", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.combiners {
                builder.set_attr_string_list("combiners", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(EnqueueTPUEmbeddingSparseBatchInst { op })
    }
}
impl EnqueueTPUEmbeddingSparseBatchInst {
    /// Returns a Vector of sample_indices for 'sample_indices' Input of this EnqueueTPUEmbeddingSparseBatch operation.
    pub fn sample_indices(&self) -> crate::Result<Vec<crate::Input>> {
        let mut Inputs = vec![];
        for i in 0..self.op.get_attr_int("N")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
    /// Returns a Vector of embedding_indices for 'embedding_indices' Input of this EnqueueTPUEmbeddingSparseBatch operation.
    pub fn embedding_indices(&self) -> crate::Result<Vec<crate::Input>> {
        let dynamic_offset = (self.op.get_attr_int("N")? + 1) as i32;
        let mut Inputs = vec![];
        for i in dynamic_offset..dynamic_offset + self.op.get_attr_int("N")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
    /// Returns a Vector of aggregation_weights for 'aggregation_weights' Input of this EnqueueTPUEmbeddingSparseBatch operation.
    pub fn aggregation_weights(&self) -> crate::Result<Vec<crate::Input>> {
        let dynamic_offset = (2 * self.op.get_attr_int("N")? + 2) as i32;
        let mut Inputs = vec![];
        for i in dynamic_offset..dynamic_offset + self.op.get_attr_int("N")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
    /// Returns the 'mode_override' Input of this 'EnqueueTPUEmbeddingSparseBatch' operation.
    pub fn mode_override(&self) -> crate::Result<crate::Input> {
        let dynamic_offset = (3 * self.op.get_attr_int("N")? + 3) as i32;
        Ok(crate::Input {
            operation: &self.op,
            index: dynamic_offset,
        })
    }
}
impl From<EnqueueTPUEmbeddingSparseBatchInst> for crate::Operation {
    fn from(inst: EnqueueTPUEmbeddingSparseBatchInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `EnqueueTPUEmbeddingSparseBatch::new().build(sample_indices, embedding_indices, aggregation_weights, mode_override, scope)`.
pub fn enqueue_tpuembedding_sparse_batch<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
>(
    sample_indices: O0,
    embedding_indices: O1,
    aggregation_weights: O2,
    mode_override: O3,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    EnqueueTPUEmbeddingSparseBatch::new().build(
        sample_indices,
        embedding_indices,
        aggregation_weights,
        mode_override,
        scope,
    )
}

/// Builder for the `EnqueueTPUEmbeddingSparseTensorBatch` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct EnqueueTPUEmbeddingSparseTensorBatch {
    T1: ::std::option::Option<crate::DataType>,
    T2: ::std::option::Option<crate::DataType>,
    T3: ::std::option::Option<crate::DataType>,
    N: ::std::option::Option<i64>,
    device_ordinal: ::std::option::Option<i64>,
    combiners: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
    table_ids: ::std::option::Option<::std::vec::Vec<i64>>,
    max_sequence_lengths: ::std::option::Option<::std::vec::Vec<i64>>,
    num_features: ::std::option::Option<::std::vec::Vec<i64>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'EnqueueTPUEmbeddingSparseTensorBatch' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct EnqueueTPUEmbeddingSparseTensorBatchInst {
    /// An instance of a fully built EnqueueTPUEmbeddingSparseTensorBatch Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl EnqueueTPUEmbeddingSparseTensorBatch {
    /// Creates a new `EnqueueTPUEmbeddingSparseTensorBatch`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T1` attribute.
    pub fn T1<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T1 = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T2` attribute.
    pub fn T2<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T2 = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T3` attribute.
    pub fn T3<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T3 = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `N` attribute.
    pub fn N<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.N = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `device_ordinal` attribute.
    pub fn device_ordinal<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.device_ordinal = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `combiners` attribute.
    pub fn combiners<ArgType: ::std::convert::Into<::std::vec::Vec<::std::string::String>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.combiners = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `table_ids` attribute.
    pub fn table_ids<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.table_ids = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `max_sequence_lengths` attribute.
    pub fn max_sequence_lengths<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.max_sequence_lengths = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `num_features` attribute.
    pub fn num_features<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.num_features = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `EnqueueTPUEmbeddingSparseTensorBatch` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
    >(
        &self,
        sample_indices: O0,
        embedding_indices: O1,
        aggregation_weights: O2,
        mode_override: O3,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            sample_indices.into(),
            embedding_indices.into(),
            aggregation_weights.into(),
            mode_override.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        sample_indices: crate::Output,
        embedding_indices: crate::Output,
        aggregation_weights: crate::Output,
        mode_override: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("EnqueueTPUEmbeddingSparseTensorBatch", |nd| {
            nd.add_input(sample_indices);
            nd.add_input(embedding_indices);
            nd.add_input(aggregation_weights);
            nd.add_input(mode_override);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T1 {
                nd.set_attr_type("T1", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T2 {
                nd.set_attr_type("T2", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T3 {
                nd.set_attr_type("T3", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.N {
                nd.set_attr_int("N", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.device_ordinal {
                nd.set_attr_int("device_ordinal", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.combiners {
                nd.set_attr_string_list("combiners", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.table_ids {
                nd.set_attr_int_list("table_ids", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.max_sequence_lengths {
                nd.set_attr_int_list("max_sequence_lengths", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_features {
                nd.set_attr_int_list("num_features", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'EnqueueTPUEmbeddingSparseTensorBatch' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        sample_indices: Vec<crate::Output>,
        embedding_indices: Vec<crate::Output>,
        aggregation_weights: Vec<crate::Output>,
        mode_override: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<EnqueueTPUEmbeddingSparseTensorBatchInst> {
        let op = scope.new_operation("EnqueueTPUEmbeddingSparseTensorBatch", |builder| {
            builder.add_input_list(&sample_indices);
            builder.add_input_list(&embedding_indices);
            builder.add_input_list(&aggregation_weights);
            builder.add_input(mode_override);
            if let ::std::option::Option::Some(value) = &self.T1 {
                builder.set_attr_type("T1", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T2 {
                builder.set_attr_type("T2", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T3 {
                builder.set_attr_type("T3", *value)?;
            }
            builder.set_attr_int("N", sample_indices.clone().len() as i64)?;
            if let ::std::option::Option::Some(value) = &self.device_ordinal {
                builder.set_attr_int("device_ordinal", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.combiners {
                builder.set_attr_string_list("combiners", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.table_ids {
                builder.set_attr_int_list("table_ids", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.max_sequence_lengths {
                builder.set_attr_int_list("max_sequence_lengths", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_features {
                builder.set_attr_int_list("num_features", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(EnqueueTPUEmbeddingSparseTensorBatchInst { op })
    }
}
impl EnqueueTPUEmbeddingSparseTensorBatchInst {
    /// Returns a Vector of sample_indices for 'sample_indices' Input of this EnqueueTPUEmbeddingSparseTensorBatch operation.
    pub fn sample_indices(&self) -> crate::Result<Vec<crate::Input>> {
        let mut Inputs = vec![];
        for i in 0..self.op.get_attr_int("N")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
    /// Returns a Vector of embedding_indices for 'embedding_indices' Input of this EnqueueTPUEmbeddingSparseTensorBatch operation.
    pub fn embedding_indices(&self) -> crate::Result<Vec<crate::Input>> {
        let dynamic_offset = (self.op.get_attr_int("N")? + 1) as i32;
        let mut Inputs = vec![];
        for i in dynamic_offset..dynamic_offset + self.op.get_attr_int("N")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
    /// Returns a Vector of aggregation_weights for 'aggregation_weights' Input of this EnqueueTPUEmbeddingSparseTensorBatch operation.
    pub fn aggregation_weights(&self) -> crate::Result<Vec<crate::Input>> {
        let dynamic_offset = (2 * self.op.get_attr_int("N")? + 2) as i32;
        let mut Inputs = vec![];
        for i in dynamic_offset..dynamic_offset + self.op.get_attr_int("N")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
    /// Returns the 'mode_override' Input of this 'EnqueueTPUEmbeddingSparseTensorBatch' operation.
    pub fn mode_override(&self) -> crate::Result<crate::Input> {
        let dynamic_offset = (3 * self.op.get_attr_int("N")? + 3) as i32;
        Ok(crate::Input {
            operation: &self.op,
            index: dynamic_offset,
        })
    }
}
impl From<EnqueueTPUEmbeddingSparseTensorBatchInst> for crate::Operation {
    fn from(inst: EnqueueTPUEmbeddingSparseTensorBatchInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `EnqueueTPUEmbeddingSparseTensorBatch::new().build(sample_indices, embedding_indices, aggregation_weights, mode_override, scope)`.
pub fn enqueue_tpuembedding_sparse_tensor_batch<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
>(
    sample_indices: O0,
    embedding_indices: O1,
    aggregation_weights: O2,
    mode_override: O3,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    EnqueueTPUEmbeddingSparseTensorBatch::new().build(
        sample_indices,
        embedding_indices,
        aggregation_weights,
        mode_override,
        scope,
    )
}

/// Builder for the `EnsureShape` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct EnsureShape {
    shape: ::std::option::Option<crate::Shape>,
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'EnsureShape' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct EnsureShapeInst {
    /// An instance of a fully built EnsureShape Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl EnsureShape {
    /// Creates a new `EnsureShape`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `shape` attribute.
    pub fn shape<ArgType: ::std::convert::Into<crate::Shape>>(mut self, value: ArgType) -> Self {
        self.shape = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `EnsureShape` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("EnsureShape", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.shape {
                nd.set_attr_shape("shape", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'EnsureShape' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<EnsureShapeInst> {
        let op = scope.new_operation("EnsureShape", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.shape {
                builder.set_attr_shape("shape", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(EnsureShapeInst { op })
    }
}
impl EnsureShapeInst {
    /// Returns the 'output' Output of this 'EnsureShape' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'EnsureShape' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<EnsureShapeInst> for crate::Operation {
    fn from(inst: EnsureShapeInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `EnsureShape::new().build(input, scope)`.
pub fn ensure_shape<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    EnsureShape::new().build(input, scope)
}

/// Builder for the `Enter` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Enter {
    T: ::std::option::Option<crate::DataType>,
    frame_name: ::std::option::Option<::std::string::String>,
    is_constant: ::std::option::Option<bool>,
    parallel_iterations: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Enter' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct EnterInst {
    /// An instance of a fully built Enter Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Enter {
    /// Creates a new `Enter`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `frame_name` attribute.
    pub fn frame_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.frame_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `is_constant` attribute.
    pub fn is_constant<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.is_constant = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `parallel_iterations` attribute.
    pub fn parallel_iterations<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.parallel_iterations = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Enter` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        data: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(data.into(), scope)
    }
    fn build_impl(
        &self,
        data: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Enter", |nd| {
            nd.add_input(data);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.frame_name {
                nd.set_attr_string("frame_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.is_constant {
                nd.set_attr_bool("is_constant", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.parallel_iterations {
                nd.set_attr_int("parallel_iterations", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Enter' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        data: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<EnterInst> {
        let op = scope.new_operation("Enter", |builder| {
            builder.add_input(data);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.frame_name {
                builder.set_attr_string("frame_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.is_constant {
                builder.set_attr_bool("is_constant", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.parallel_iterations {
                builder.set_attr_int("parallel_iterations", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(EnterInst { op })
    }
}
impl EnterInst {
    /// Returns the 'output' Output of this 'Enter' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'data' Input of this 'Enter' operation.
    pub fn data(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<EnterInst> for crate::Operation {
    fn from(inst: EnterInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Enter::new().build(data, scope)`.
pub fn enter<O0: ::std::convert::Into<crate::Output>>(
    data: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Enter::new().build(data, scope)
}

/// Builder for the `Equal` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Equal {
    T: ::std::option::Option<crate::DataType>,
    incompatible_shape_error: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Equal' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct EqualInst {
    /// An instance of a fully built Equal Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Equal {
    /// Creates a new `Equal`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `incompatible_shape_error` attribute.
    pub fn incompatible_shape_error<ArgType: ::std::convert::Into<bool>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.incompatible_shape_error = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Equal` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        x: O0,
        y: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), y.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        y: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Equal", |nd| {
            nd.add_input(x);
            nd.add_input(y);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.incompatible_shape_error {
                nd.set_attr_bool("incompatible_shape_error", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Equal' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        y: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<EqualInst> {
        let op = scope.new_operation("Equal", |builder| {
            builder.add_input(x);
            builder.add_input(y);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.incompatible_shape_error {
                builder.set_attr_bool("incompatible_shape_error", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(EqualInst { op })
    }
}
impl EqualInst {
    /// Returns the 'z' Output of this 'Equal' operation.
    pub fn z(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'Equal' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'y' Input of this 'Equal' operation.
    pub fn y(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<EqualInst> for crate::Operation {
    fn from(inst: EqualInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Equal::new().build(x, y, scope)`.
pub fn equal<O0: ::std::convert::Into<crate::Output>, O1: ::std::convert::Into<crate::Output>>(
    x: O0,
    y: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Equal::new().build(x, y, scope)
}

/// Builder for the `Erf` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Erf {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Erf' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ErfInst {
    /// An instance of a fully built Erf Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Erf {
    /// Creates a new `Erf`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Erf` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        x: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Erf", |nd| {
            nd.add_input(x);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Erf' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ErfInst> {
        let op = scope.new_operation("Erf", |builder| {
            builder.add_input(x);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ErfInst { op })
    }
}
impl ErfInst {
    /// Returns the 'y' Output of this 'Erf' operation.
    pub fn y(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'Erf' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<ErfInst> for crate::Operation {
    fn from(inst: ErfInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Erf::new().build(x, scope)`.
pub fn erf<O0: ::std::convert::Into<crate::Output>>(
    x: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Erf::new().build(x, scope)
}

/// Builder for the `Erfc` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Erfc {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Erfc' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ErfcInst {
    /// An instance of a fully built Erfc Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Erfc {
    /// Creates a new `Erfc`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Erfc` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        x: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Erfc", |nd| {
            nd.add_input(x);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Erfc' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ErfcInst> {
        let op = scope.new_operation("Erfc", |builder| {
            builder.add_input(x);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ErfcInst { op })
    }
}
impl ErfcInst {
    /// Returns the 'y' Output of this 'Erfc' operation.
    pub fn y(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'Erfc' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<ErfcInst> for crate::Operation {
    fn from(inst: ErfcInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Erfc::new().build(x, scope)`.
pub fn erfc<O0: ::std::convert::Into<crate::Output>>(
    x: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Erfc::new().build(x, scope)
}

/// Builder for the `Erfinv` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Erfinv {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Erfinv' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ErfinvInst {
    /// An instance of a fully built Erfinv Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Erfinv {
    /// Creates a new `Erfinv`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Erfinv` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        x: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Erfinv", |nd| {
            nd.add_input(x);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Erfinv' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ErfinvInst> {
        let op = scope.new_operation("Erfinv", |builder| {
            builder.add_input(x);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ErfinvInst { op })
    }
}
impl ErfinvInst {
    /// Returns the 'y' Output of this 'Erfinv' operation.
    pub fn y(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'Erfinv' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<ErfinvInst> for crate::Operation {
    fn from(inst: ErfinvInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Erfinv::new().build(x, scope)`.
pub fn erfinv<O0: ::std::convert::Into<crate::Output>>(
    x: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Erfinv::new().build(x, scope)
}

/// Builder for the `EuclideanNorm` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct EuclideanNorm {
    keep_dims: ::std::option::Option<bool>,
    T: ::std::option::Option<crate::DataType>,
    Tidx: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'EuclideanNorm' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct EuclideanNormInst {
    /// An instance of a fully built EuclideanNorm Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl EuclideanNorm {
    /// Creates a new `EuclideanNorm`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `keep_dims` attribute.
    pub fn keep_dims<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.keep_dims = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tidx` attribute.
    pub fn Tidx<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Tidx = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `EuclideanNorm` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        reduction_indices: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), reduction_indices.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        reduction_indices: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("EuclideanNorm", |nd| {
            nd.add_input(input);
            nd.add_input(reduction_indices);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.keep_dims {
                nd.set_attr_bool("keep_dims", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tidx {
                nd.set_attr_type("Tidx", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'EuclideanNorm' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        reduction_indices: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<EuclideanNormInst> {
        let op = scope.new_operation("EuclideanNorm", |builder| {
            builder.add_input(input);
            builder.add_input(reduction_indices);
            if let ::std::option::Option::Some(value) = &self.keep_dims {
                builder.set_attr_bool("keep_dims", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tidx {
                builder.set_attr_type("Tidx", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(EuclideanNormInst { op })
    }
}
impl EuclideanNormInst {
    /// Returns the 'output' Output of this 'EuclideanNorm' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'EuclideanNorm' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'reduction_indices' Input of this 'EuclideanNorm' operation.
    pub fn reduction_indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<EuclideanNormInst> for crate::Operation {
    fn from(inst: EuclideanNormInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `EuclideanNorm::new().build(input, reduction_indices, scope)`.
pub fn euclidean_norm<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    input: O0,
    reduction_indices: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    EuclideanNorm::new().build(input, reduction_indices, scope)
}

/// Builder for the `ExecuteTPUEmbeddingPartitioner` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ExecuteTPUEmbeddingPartitioner {
    config: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ExecuteTPUEmbeddingPartitioner' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ExecuteTPUEmbeddingPartitionerInst {
    /// An instance of a fully built ExecuteTPUEmbeddingPartitioner Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ExecuteTPUEmbeddingPartitioner {
    /// Creates a new `ExecuteTPUEmbeddingPartitioner`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `config` attribute.
    pub fn config<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.config = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ExecuteTPUEmbeddingPartitioner` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("ExecuteTPUEmbeddingPartitioner", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.config {
                nd.set_attr_string("config", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ExecuteTPUEmbeddingPartitioner' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        scope: &mut crate::Scope,
    ) -> crate::Result<ExecuteTPUEmbeddingPartitionerInst> {
        let op = scope.new_operation("ExecuteTPUEmbeddingPartitioner", |builder| {
            if let ::std::option::Option::Some(value) = &self.config {
                builder.set_attr_string("config", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ExecuteTPUEmbeddingPartitionerInst { op })
    }
}
impl ExecuteTPUEmbeddingPartitionerInst {
    /// Returns the 'common_config' Output of this 'ExecuteTPUEmbeddingPartitioner' operation.
    pub fn common_config(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
}
impl From<ExecuteTPUEmbeddingPartitionerInst> for crate::Operation {
    fn from(inst: ExecuteTPUEmbeddingPartitionerInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ExecuteTPUEmbeddingPartitioner::new().build(scope)`.
pub fn execute_tpuembedding_partitioner(
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ExecuteTPUEmbeddingPartitioner::new().build(scope)
}

/// Builder for the `Exit` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Exit {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Exit' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ExitInst {
    /// An instance of a fully built Exit Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Exit {
    /// Creates a new `Exit`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Exit` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        data: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(data.into(), scope)
    }
    fn build_impl(
        &self,
        data: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Exit", |nd| {
            nd.add_input(data);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Exit' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        data: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ExitInst> {
        let op = scope.new_operation("Exit", |builder| {
            builder.add_input(data);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ExitInst { op })
    }
}
impl ExitInst {
    /// Returns the 'output' Output of this 'Exit' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'data' Input of this 'Exit' operation.
    pub fn data(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<ExitInst> for crate::Operation {
    fn from(inst: ExitInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Exit::new().build(data, scope)`.
pub fn exit<O0: ::std::convert::Into<crate::Output>>(
    data: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Exit::new().build(data, scope)
}

/// Builder for the `Exp` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Exp {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Exp' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ExpInst {
    /// An instance of a fully built Exp Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Exp {
    /// Creates a new `Exp`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Exp` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        x: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Exp", |nd| {
            nd.add_input(x);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Exp' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ExpInst> {
        let op = scope.new_operation("Exp", |builder| {
            builder.add_input(x);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ExpInst { op })
    }
}
impl ExpInst {
    /// Returns the 'y' Output of this 'Exp' operation.
    pub fn y(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'Exp' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<ExpInst> for crate::Operation {
    fn from(inst: ExpInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Exp::new().build(x, scope)`.
pub fn exp<O0: ::std::convert::Into<crate::Output>>(
    x: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Exp::new().build(x, scope)
}

/// Builder for the `ExpandDims` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ExpandDims {
    T: ::std::option::Option<crate::DataType>,
    Tdim: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ExpandDims' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ExpandDimsInst {
    /// An instance of a fully built ExpandDims Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ExpandDims {
    /// Creates a new `ExpandDims`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tdim` attribute.
    pub fn Tdim<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Tdim = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ExpandDims` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        dim: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), dim.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        dim: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ExpandDims", |nd| {
            nd.add_input(input);
            nd.add_input(dim);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tdim {
                nd.set_attr_type("Tdim", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ExpandDims' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        dim: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ExpandDimsInst> {
        let op = scope.new_operation("ExpandDims", |builder| {
            builder.add_input(input);
            builder.add_input(dim);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tdim {
                builder.set_attr_type("Tdim", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ExpandDimsInst { op })
    }
}
impl ExpandDimsInst {
    /// Returns the 'output' Output of this 'ExpandDims' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'ExpandDims' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'dim' Input of this 'ExpandDims' operation.
    pub fn dim(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<ExpandDimsInst> for crate::Operation {
    fn from(inst: ExpandDimsInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ExpandDims::new().build(input, dim, scope)`.
pub fn expand_dims<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    input: O0,
    dim: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ExpandDims::new().build(input, dim, scope)
}

/// Builder for the `ExperimentalAssertNextDataset` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ExperimentalAssertNextDataset {
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ExperimentalAssertNextDataset' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ExperimentalAssertNextDatasetInst {
    /// An instance of a fully built ExperimentalAssertNextDataset Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ExperimentalAssertNextDataset {
    /// Creates a new `ExperimentalAssertNextDataset`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ExperimentalAssertNextDataset` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input_dataset: O0,
        transformations: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input_dataset.into(), transformations.into(), scope)
    }
    fn build_impl(
        &self,
        input_dataset: crate::Output,
        transformations: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ExperimentalAssertNextDataset", |nd| {
            nd.add_input(input_dataset);
            nd.add_input(transformations);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ExperimentalAssertNextDataset' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_dataset: crate::Output,
        transformations: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ExperimentalAssertNextDatasetInst> {
        let op = scope.new_operation("ExperimentalAssertNextDataset", |builder| {
            builder.add_input(input_dataset);
            builder.add_input(transformations);
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ExperimentalAssertNextDatasetInst { op })
    }
}
impl ExperimentalAssertNextDatasetInst {
    /// Returns the 'handle' Output of this 'ExperimentalAssertNextDataset' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_dataset' Input of this 'ExperimentalAssertNextDataset' operation.
    pub fn input_dataset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'transformations' Input of this 'ExperimentalAssertNextDataset' operation.
    pub fn transformations(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<ExperimentalAssertNextDatasetInst> for crate::Operation {
    fn from(inst: ExperimentalAssertNextDatasetInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ExperimentalAssertNextDataset::new().build(input_dataset, transformations, scope)`.
pub fn experimental_assert_next_dataset<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    input_dataset: O0,
    transformations: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ExperimentalAssertNextDataset::new().build(input_dataset, transformations, scope)
}

/// Builder for the `ExperimentalAutoShardDataset` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ExperimentalAutoShardDataset {
    auto_shard_policy: ::std::option::Option<i64>,
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ExperimentalAutoShardDataset' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ExperimentalAutoShardDatasetInst {
    /// An instance of a fully built ExperimentalAutoShardDataset Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ExperimentalAutoShardDataset {
    /// Creates a new `ExperimentalAutoShardDataset`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `auto_shard_policy` attribute.
    pub fn auto_shard_policy<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.auto_shard_policy = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ExperimentalAutoShardDataset` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input_dataset: O0,
        num_workers: O1,
        index: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            input_dataset.into(),
            num_workers.into(),
            index.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        input_dataset: crate::Output,
        num_workers: crate::Output,
        index: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ExperimentalAutoShardDataset", |nd| {
            nd.add_input(input_dataset);
            nd.add_input(num_workers);
            nd.add_input(index);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.auto_shard_policy {
                nd.set_attr_int("auto_shard_policy", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ExperimentalAutoShardDataset' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_dataset: crate::Output,
        num_workers: crate::Output,
        index: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ExperimentalAutoShardDatasetInst> {
        let op = scope.new_operation("ExperimentalAutoShardDataset", |builder| {
            builder.add_input(input_dataset);
            builder.add_input(num_workers);
            builder.add_input(index);
            if let ::std::option::Option::Some(value) = &self.auto_shard_policy {
                builder.set_attr_int("auto_shard_policy", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ExperimentalAutoShardDatasetInst { op })
    }
}
impl ExperimentalAutoShardDatasetInst {
    /// Returns the 'handle' Output of this 'ExperimentalAutoShardDataset' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_dataset' Input of this 'ExperimentalAutoShardDataset' operation.
    pub fn input_dataset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'num_workers' Input of this 'ExperimentalAutoShardDataset' operation.
    pub fn num_workers(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'index' Input of this 'ExperimentalAutoShardDataset' operation.
    pub fn index(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<ExperimentalAutoShardDatasetInst> for crate::Operation {
    fn from(inst: ExperimentalAutoShardDatasetInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ExperimentalAutoShardDataset::new().build(input_dataset, num_workers, index, scope)`.
pub fn experimental_auto_shard_dataset<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    input_dataset: O0,
    num_workers: O1,
    index: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ExperimentalAutoShardDataset::new().build(input_dataset, num_workers, index, scope)
}

/// Builder for the `ExperimentalBytesProducedStatsDataset` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ExperimentalBytesProducedStatsDataset {
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ExperimentalBytesProducedStatsDataset' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ExperimentalBytesProducedStatsDatasetInst {
    /// An instance of a fully built ExperimentalBytesProducedStatsDataset Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ExperimentalBytesProducedStatsDataset {
    /// Creates a new `ExperimentalBytesProducedStatsDataset`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ExperimentalBytesProducedStatsDataset` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input_dataset: O0,
        tag: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input_dataset.into(), tag.into(), scope)
    }
    fn build_impl(
        &self,
        input_dataset: crate::Output,
        tag: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ExperimentalBytesProducedStatsDataset", |nd| {
            nd.add_input(input_dataset);
            nd.add_input(tag);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ExperimentalBytesProducedStatsDataset' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_dataset: crate::Output,
        tag: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ExperimentalBytesProducedStatsDatasetInst> {
        let op = scope.new_operation("ExperimentalBytesProducedStatsDataset", |builder| {
            builder.add_input(input_dataset);
            builder.add_input(tag);
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ExperimentalBytesProducedStatsDatasetInst { op })
    }
}
impl ExperimentalBytesProducedStatsDatasetInst {
    /// Returns the 'handle' Output of this 'ExperimentalBytesProducedStatsDataset' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_dataset' Input of this 'ExperimentalBytesProducedStatsDataset' operation.
    pub fn input_dataset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'tag' Input of this 'ExperimentalBytesProducedStatsDataset' operation.
    pub fn tag(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<ExperimentalBytesProducedStatsDatasetInst> for crate::Operation {
    fn from(inst: ExperimentalBytesProducedStatsDatasetInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ExperimentalBytesProducedStatsDataset::new().build(input_dataset, tag, scope)`.
pub fn experimental_bytes_produced_stats_dataset<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    input_dataset: O0,
    tag: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ExperimentalBytesProducedStatsDataset::new().build(input_dataset, tag, scope)
}

/// Builder for the `ExperimentalCSVDataset` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ExperimentalCSVDataset {
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ExperimentalCSVDataset' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ExperimentalCSVDatasetInst {
    /// An instance of a fully built ExperimentalCSVDataset Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ExperimentalCSVDataset {
    /// Creates a new `ExperimentalCSVDataset`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ExperimentalCSVDataset` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
        O6: ::std::convert::Into<crate::Output>,
        O7: ::std::convert::Into<crate::Output>,
        O8: ::std::convert::Into<crate::Output>,
    >(
        &self,
        filenames: O0,
        compression_type: O1,
        buffer_size: O2,
        header: O3,
        field_delim: O4,
        use_quote_delim: O5,
        na_value: O6,
        select_cols: O7,
        record_defaults: O8,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            filenames.into(),
            compression_type.into(),
            buffer_size.into(),
            header.into(),
            field_delim.into(),
            use_quote_delim.into(),
            na_value.into(),
            select_cols.into(),
            record_defaults.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        filenames: crate::Output,
        compression_type: crate::Output,
        buffer_size: crate::Output,
        header: crate::Output,
        field_delim: crate::Output,
        use_quote_delim: crate::Output,
        na_value: crate::Output,
        select_cols: crate::Output,
        record_defaults: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ExperimentalCSVDataset", |nd| {
            nd.add_input(filenames);
            nd.add_input(compression_type);
            nd.add_input(buffer_size);
            nd.add_input(header);
            nd.add_input(field_delim);
            nd.add_input(use_quote_delim);
            nd.add_input(na_value);
            nd.add_input(select_cols);
            nd.add_input(record_defaults);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ExperimentalCSVDataset' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        filenames: crate::Output,
        compression_type: crate::Output,
        buffer_size: crate::Output,
        header: crate::Output,
        field_delim: crate::Output,
        use_quote_delim: crate::Output,
        na_value: crate::Output,
        select_cols: crate::Output,
        record_defaults: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ExperimentalCSVDatasetInst> {
        let op = scope.new_operation("ExperimentalCSVDataset", |builder| {
            builder.add_input(filenames);
            builder.add_input(compression_type);
            builder.add_input(buffer_size);
            builder.add_input(header);
            builder.add_input(field_delim);
            builder.add_input(use_quote_delim);
            builder.add_input(na_value);
            builder.add_input(select_cols);
            builder.add_input(record_defaults);
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ExperimentalCSVDatasetInst { op })
    }
}
impl ExperimentalCSVDatasetInst {
    /// Returns the 'handle' Output of this 'ExperimentalCSVDataset' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'filenames' Input of this 'ExperimentalCSVDataset' operation.
    pub fn filenames(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'compression_type' Input of this 'ExperimentalCSVDataset' operation.
    pub fn compression_type(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'buffer_size' Input of this 'ExperimentalCSVDataset' operation.
    pub fn buffer_size(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'header' Input of this 'ExperimentalCSVDataset' operation.
    pub fn header(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'field_delim' Input of this 'ExperimentalCSVDataset' operation.
    pub fn field_delim(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
    /// Returns the 'use_quote_delim' Input of this 'ExperimentalCSVDataset' operation.
    pub fn use_quote_delim(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 5,
        }
    }
    /// Returns the 'na_value' Input of this 'ExperimentalCSVDataset' operation.
    pub fn na_value(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 6,
        }
    }
    /// Returns the 'select_cols' Input of this 'ExperimentalCSVDataset' operation.
    pub fn select_cols(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 7,
        }
    }
    /// Returns the 'record_defaults' Input of this 'ExperimentalCSVDataset' operation.
    pub fn record_defaults(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 8,
        }
    }
}
impl From<ExperimentalCSVDatasetInst> for crate::Operation {
    fn from(inst: ExperimentalCSVDatasetInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ExperimentalCSVDataset::new().build(filenames, compression_type, buffer_size, header, field_delim, use_quote_delim, na_value, select_cols, record_defaults, scope)`.
pub fn experimental_csvdataset<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
    O6: ::std::convert::Into<crate::Output>,
    O7: ::std::convert::Into<crate::Output>,
    O8: ::std::convert::Into<crate::Output>,
>(
    filenames: O0,
    compression_type: O1,
    buffer_size: O2,
    header: O3,
    field_delim: O4,
    use_quote_delim: O5,
    na_value: O6,
    select_cols: O7,
    record_defaults: O8,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ExperimentalCSVDataset::new().build(
        filenames,
        compression_type,
        buffer_size,
        header,
        field_delim,
        use_quote_delim,
        na_value,
        select_cols,
        record_defaults,
        scope,
    )
}

/// Builder for the `ExperimentalChooseFastestDataset` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ExperimentalChooseFastestDataset {
    N: ::std::option::Option<i64>,
    num_experiments: ::std::option::Option<i64>,
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ExperimentalChooseFastestDataset' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ExperimentalChooseFastestDatasetInst {
    /// An instance of a fully built ExperimentalChooseFastestDataset Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ExperimentalChooseFastestDataset {
    /// Creates a new `ExperimentalChooseFastestDataset`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `N` attribute.
    pub fn N<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.N = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `num_experiments` attribute.
    pub fn num_experiments<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.num_experiments = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ExperimentalChooseFastestDataset` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input_datasets: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input_datasets.into(), scope)
    }
    fn build_impl(
        &self,
        input_datasets: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ExperimentalChooseFastestDataset", |nd| {
            nd.add_input(input_datasets);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.N {
                nd.set_attr_int("N", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_experiments {
                nd.set_attr_int("num_experiments", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ExperimentalChooseFastestDataset' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_datasets: Vec<crate::Output>,
        scope: &mut crate::Scope,
    ) -> crate::Result<ExperimentalChooseFastestDatasetInst> {
        let op = scope.new_operation("ExperimentalChooseFastestDataset", |builder| {
            builder.add_input_list(&input_datasets);
            builder.set_attr_int("N", input_datasets.clone().len() as i64)?;
            if let ::std::option::Option::Some(value) = &self.num_experiments {
                builder.set_attr_int("num_experiments", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ExperimentalChooseFastestDatasetInst { op })
    }
}
impl ExperimentalChooseFastestDatasetInst {
    /// Returns the 'handle' Output of this 'ExperimentalChooseFastestDataset' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns a Vector of input_datasets for 'input_datasets' Input of this ExperimentalChooseFastestDataset operation.
    pub fn input_datasets(&self) -> crate::Result<Vec<crate::Input>> {
        let mut Inputs = vec![];
        for i in 0..self.op.get_attr_int("N")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
}
impl From<ExperimentalChooseFastestDatasetInst> for crate::Operation {
    fn from(inst: ExperimentalChooseFastestDatasetInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ExperimentalChooseFastestDataset::new().build(input_datasets, scope)`.
pub fn experimental_choose_fastest_dataset<O0: ::std::convert::Into<crate::Output>>(
    input_datasets: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ExperimentalChooseFastestDataset::new().build(input_datasets, scope)
}

/// Builder for the `ExperimentalDatasetCardinality` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ExperimentalDatasetCardinality {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ExperimentalDatasetCardinality' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ExperimentalDatasetCardinalityInst {
    /// An instance of a fully built ExperimentalDatasetCardinality Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ExperimentalDatasetCardinality {
    /// Creates a new `ExperimentalDatasetCardinality`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ExperimentalDatasetCardinality` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input_dataset: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input_dataset.into(), scope)
    }
    fn build_impl(
        &self,
        input_dataset: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ExperimentalDatasetCardinality", |nd| {
            nd.add_input(input_dataset);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ExperimentalDatasetCardinality' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_dataset: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ExperimentalDatasetCardinalityInst> {
        let op = scope.new_operation("ExperimentalDatasetCardinality", |builder| {
            builder.add_input(input_dataset);
            ::std::result::Result::Ok(())
        })?;
        Ok(ExperimentalDatasetCardinalityInst { op })
    }
}
impl ExperimentalDatasetCardinalityInst {
    /// Returns the 'cardinality' Output of this 'ExperimentalDatasetCardinality' operation.
    pub fn cardinality(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_dataset' Input of this 'ExperimentalDatasetCardinality' operation.
    pub fn input_dataset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<ExperimentalDatasetCardinalityInst> for crate::Operation {
    fn from(inst: ExperimentalDatasetCardinalityInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ExperimentalDatasetCardinality::new().build(input_dataset, scope)`.
pub fn experimental_dataset_cardinality<O0: ::std::convert::Into<crate::Output>>(
    input_dataset: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ExperimentalDatasetCardinality::new().build(input_dataset, scope)
}

/// Builder for the `ExperimentalDatasetToTFRecord` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ExperimentalDatasetToTFRecord {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ExperimentalDatasetToTFRecord' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ExperimentalDatasetToTFRecordInst {
    /// An instance of a fully built ExperimentalDatasetToTFRecord Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ExperimentalDatasetToTFRecord {
    /// Creates a new `ExperimentalDatasetToTFRecord`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ExperimentalDatasetToTFRecord` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input_dataset: O0,
        filename: O1,
        compression_type: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            input_dataset.into(),
            filename.into(),
            compression_type.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        input_dataset: crate::Output,
        filename: crate::Output,
        compression_type: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ExperimentalDatasetToTFRecord", |nd| {
            nd.add_input(input_dataset);
            nd.add_input(filename);
            nd.add_input(compression_type);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ExperimentalDatasetToTFRecord' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_dataset: crate::Output,
        filename: crate::Output,
        compression_type: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ExperimentalDatasetToTFRecordInst> {
        let op = scope.new_operation("ExperimentalDatasetToTFRecord", |builder| {
            builder.add_input(input_dataset);
            builder.add_input(filename);
            builder.add_input(compression_type);
            ::std::result::Result::Ok(())
        })?;
        Ok(ExperimentalDatasetToTFRecordInst { op })
    }
}
impl ExperimentalDatasetToTFRecordInst {
    /// Returns the 'input_dataset' Input of this 'ExperimentalDatasetToTFRecord' operation.
    pub fn input_dataset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'filename' Input of this 'ExperimentalDatasetToTFRecord' operation.
    pub fn filename(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'compression_type' Input of this 'ExperimentalDatasetToTFRecord' operation.
    pub fn compression_type(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<ExperimentalDatasetToTFRecordInst> for crate::Operation {
    fn from(inst: ExperimentalDatasetToTFRecordInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ExperimentalDatasetToTFRecord::new().build(input_dataset, filename, compression_type, scope)`.
pub fn experimental_dataset_to_tfrecord<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    input_dataset: O0,
    filename: O1,
    compression_type: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ExperimentalDatasetToTFRecord::new().build(input_dataset, filename, compression_type, scope)
}

/// Builder for the `ExperimentalDenseToSparseBatchDataset` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ExperimentalDenseToSparseBatchDataset {
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ExperimentalDenseToSparseBatchDataset' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ExperimentalDenseToSparseBatchDatasetInst {
    /// An instance of a fully built ExperimentalDenseToSparseBatchDataset Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ExperimentalDenseToSparseBatchDataset {
    /// Creates a new `ExperimentalDenseToSparseBatchDataset`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ExperimentalDenseToSparseBatchDataset` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input_dataset: O0,
        batch_size: O1,
        row_shape: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            input_dataset.into(),
            batch_size.into(),
            row_shape.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        input_dataset: crate::Output,
        batch_size: crate::Output,
        row_shape: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ExperimentalDenseToSparseBatchDataset", |nd| {
            nd.add_input(input_dataset);
            nd.add_input(batch_size);
            nd.add_input(row_shape);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ExperimentalDenseToSparseBatchDataset' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_dataset: crate::Output,
        batch_size: crate::Output,
        row_shape: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ExperimentalDenseToSparseBatchDatasetInst> {
        let op = scope.new_operation("ExperimentalDenseToSparseBatchDataset", |builder| {
            builder.add_input(input_dataset);
            builder.add_input(batch_size);
            builder.add_input(row_shape);
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ExperimentalDenseToSparseBatchDatasetInst { op })
    }
}
impl ExperimentalDenseToSparseBatchDatasetInst {
    /// Returns the 'handle' Output of this 'ExperimentalDenseToSparseBatchDataset' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_dataset' Input of this 'ExperimentalDenseToSparseBatchDataset' operation.
    pub fn input_dataset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'batch_size' Input of this 'ExperimentalDenseToSparseBatchDataset' operation.
    pub fn batch_size(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'row_shape' Input of this 'ExperimentalDenseToSparseBatchDataset' operation.
    pub fn row_shape(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<ExperimentalDenseToSparseBatchDatasetInst> for crate::Operation {
    fn from(inst: ExperimentalDenseToSparseBatchDatasetInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ExperimentalDenseToSparseBatchDataset::new().build(input_dataset, batch_size, row_shape, scope)`.
pub fn experimental_dense_to_sparse_batch_dataset<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    input_dataset: O0,
    batch_size: O1,
    row_shape: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ExperimentalDenseToSparseBatchDataset::new().build(input_dataset, batch_size, row_shape, scope)
}

/// Builder for the `ExperimentalDirectedInterleaveDataset` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ExperimentalDirectedInterleaveDataset {
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    N: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ExperimentalDirectedInterleaveDataset' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ExperimentalDirectedInterleaveDatasetInst {
    /// An instance of a fully built ExperimentalDirectedInterleaveDataset Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ExperimentalDirectedInterleaveDataset {
    /// Creates a new `ExperimentalDirectedInterleaveDataset`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `N` attribute.
    pub fn N<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.N = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ExperimentalDirectedInterleaveDataset` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        selector_input_dataset: O0,
        data_input_datasets: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            selector_input_dataset.into(),
            data_input_datasets.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        selector_input_dataset: crate::Output,
        data_input_datasets: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ExperimentalDirectedInterleaveDataset", |nd| {
            nd.add_input(selector_input_dataset);
            nd.add_input(data_input_datasets);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.N {
                nd.set_attr_int("N", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ExperimentalDirectedInterleaveDataset' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        selector_input_dataset: crate::Output,
        data_input_datasets: Vec<crate::Output>,
        scope: &mut crate::Scope,
    ) -> crate::Result<ExperimentalDirectedInterleaveDatasetInst> {
        let op = scope.new_operation("ExperimentalDirectedInterleaveDataset", |builder| {
            builder.add_input(selector_input_dataset);
            builder.add_input_list(&data_input_datasets);
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            builder.set_attr_int("N", data_input_datasets.clone().len() as i64)?;
            ::std::result::Result::Ok(())
        })?;
        Ok(ExperimentalDirectedInterleaveDatasetInst { op })
    }
}
impl ExperimentalDirectedInterleaveDatasetInst {
    /// Returns the 'handle' Output of this 'ExperimentalDirectedInterleaveDataset' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'selector_input_dataset' Input of this 'ExperimentalDirectedInterleaveDataset' operation.
    pub fn selector_input_dataset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns a Vector of data_input_datasets for 'data_input_datasets' Input of this ExperimentalDirectedInterleaveDataset operation.
    pub fn data_input_datasets(&self) -> crate::Result<Vec<crate::Input>> {
        let mut Inputs = vec![];
        for i in 1..self.op.get_attr_int("N")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
}
impl From<ExperimentalDirectedInterleaveDatasetInst> for crate::Operation {
    fn from(inst: ExperimentalDirectedInterleaveDatasetInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ExperimentalDirectedInterleaveDataset::new().build(selector_input_dataset, data_input_datasets, scope)`.
pub fn experimental_directed_interleave_dataset<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    selector_input_dataset: O0,
    data_input_datasets: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ExperimentalDirectedInterleaveDataset::new().build(
        selector_input_dataset,
        data_input_datasets,
        scope,
    )
}

/// Builder for the `ExperimentalGroupByReducerDataset` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ExperimentalGroupByReducerDataset {
    key_func: ::std::option::Option<::std::string::String>,
    init_func: ::std::option::Option<::std::string::String>,
    reduce_func: ::std::option::Option<::std::string::String>,
    finalize_func: ::std::option::Option<::std::string::String>,
    Tkey_func_other_arguments: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    Tinit_func_other_arguments: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    Treduce_func_other_arguments: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    Tfinalize_func_other_arguments: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ExperimentalGroupByReducerDataset' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ExperimentalGroupByReducerDatasetInst {
    /// An instance of a fully built ExperimentalGroupByReducerDataset Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ExperimentalGroupByReducerDataset {
    /// Creates a new `ExperimentalGroupByReducerDataset`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `key_func` attribute.
    pub fn key_func<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.key_func = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `init_func` attribute.
    pub fn init_func<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.init_func = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `reduce_func` attribute.
    pub fn reduce_func<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.reduce_func = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `finalize_func` attribute.
    pub fn finalize_func<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.finalize_func = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tkey_func_other_arguments` attribute.
    pub fn Tkey_func_other_arguments<
        ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>,
    >(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tkey_func_other_arguments = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tinit_func_other_arguments` attribute.
    pub fn Tinit_func_other_arguments<
        ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>,
    >(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tinit_func_other_arguments = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Treduce_func_other_arguments` attribute.
    pub fn Treduce_func_other_arguments<
        ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>,
    >(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Treduce_func_other_arguments = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tfinalize_func_other_arguments` attribute.
    pub fn Tfinalize_func_other_arguments<
        ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>,
    >(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tfinalize_func_other_arguments = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ExperimentalGroupByReducerDataset` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input_dataset: O0,
        key_func_other_arguments: O1,
        init_func_other_arguments: O2,
        reduce_func_other_arguments: O3,
        finalize_func_other_arguments: O4,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            input_dataset.into(),
            key_func_other_arguments.into(),
            init_func_other_arguments.into(),
            reduce_func_other_arguments.into(),
            finalize_func_other_arguments.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        input_dataset: crate::Output,
        key_func_other_arguments: crate::Output,
        init_func_other_arguments: crate::Output,
        reduce_func_other_arguments: crate::Output,
        finalize_func_other_arguments: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ExperimentalGroupByReducerDataset", |nd| {
            nd.add_input(input_dataset);
            nd.add_input(key_func_other_arguments);
            nd.add_input(init_func_other_arguments);
            nd.add_input(reduce_func_other_arguments);
            nd.add_input(finalize_func_other_arguments);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.key_func {
                nd.set_attr_string("key_func", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.init_func {
                nd.set_attr_string("init_func", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.reduce_func {
                nd.set_attr_string("reduce_func", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.finalize_func {
                nd.set_attr_string("finalize_func", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tkey_func_other_arguments {
                nd.set_attr_type_list("Tkey_func_other_arguments", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tinit_func_other_arguments {
                nd.set_attr_type_list("Tinit_func_other_arguments", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Treduce_func_other_arguments {
                nd.set_attr_type_list("Treduce_func_other_arguments", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tfinalize_func_other_arguments {
                nd.set_attr_type_list("Tfinalize_func_other_arguments", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ExperimentalGroupByReducerDataset' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_dataset: crate::Output,
        key_func_other_arguments: crate::Output,
        init_func_other_arguments: crate::Output,
        reduce_func_other_arguments: crate::Output,
        finalize_func_other_arguments: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ExperimentalGroupByReducerDatasetInst> {
        let op = scope.new_operation("ExperimentalGroupByReducerDataset", |builder| {
            builder.add_input(input_dataset);
            builder.add_input(key_func_other_arguments);
            builder.add_input(init_func_other_arguments);
            builder.add_input(reduce_func_other_arguments);
            builder.add_input(finalize_func_other_arguments);
            if let ::std::option::Option::Some(value) = &self.key_func {
                builder.set_attr_string("key_func", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.init_func {
                builder.set_attr_string("init_func", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.reduce_func {
                builder.set_attr_string("reduce_func", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.finalize_func {
                builder.set_attr_string("finalize_func", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tkey_func_other_arguments {
                builder.set_attr_type_list("Tkey_func_other_arguments", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tinit_func_other_arguments {
                builder.set_attr_type_list("Tinit_func_other_arguments", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Treduce_func_other_arguments {
                builder.set_attr_type_list("Treduce_func_other_arguments", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tfinalize_func_other_arguments {
                builder.set_attr_type_list("Tfinalize_func_other_arguments", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ExperimentalGroupByReducerDatasetInst { op })
    }
}
impl ExperimentalGroupByReducerDatasetInst {
    /// Returns the 'handle' Output of this 'ExperimentalGroupByReducerDataset' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_dataset' Input of this 'ExperimentalGroupByReducerDataset' operation.
    pub fn input_dataset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'key_func_other_arguments' Input of this 'ExperimentalGroupByReducerDataset' operation.
    pub fn key_func_other_arguments(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'init_func_other_arguments' Input of this 'ExperimentalGroupByReducerDataset' operation.
    pub fn init_func_other_arguments(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'reduce_func_other_arguments' Input of this 'ExperimentalGroupByReducerDataset' operation.
    pub fn reduce_func_other_arguments(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'finalize_func_other_arguments' Input of this 'ExperimentalGroupByReducerDataset' operation.
    pub fn finalize_func_other_arguments(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
}
impl From<ExperimentalGroupByReducerDatasetInst> for crate::Operation {
    fn from(inst: ExperimentalGroupByReducerDatasetInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ExperimentalGroupByReducerDataset::new().build(input_dataset, key_func_other_arguments, init_func_other_arguments, reduce_func_other_arguments, finalize_func_other_arguments, scope)`.
pub fn experimental_group_by_reducer_dataset<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
>(
    input_dataset: O0,
    key_func_other_arguments: O1,
    init_func_other_arguments: O2,
    reduce_func_other_arguments: O3,
    finalize_func_other_arguments: O4,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ExperimentalGroupByReducerDataset::new().build(
        input_dataset,
        key_func_other_arguments,
        init_func_other_arguments,
        reduce_func_other_arguments,
        finalize_func_other_arguments,
        scope,
    )
}

/// Builder for the `ExperimentalGroupByWindowDataset` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ExperimentalGroupByWindowDataset {
    key_func: ::std::option::Option<::std::string::String>,
    reduce_func: ::std::option::Option<::std::string::String>,
    window_size_func: ::std::option::Option<::std::string::String>,
    Tkey_func_other_arguments: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    Treduce_func_other_arguments: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    Twindow_size_func_other_arguments: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ExperimentalGroupByWindowDataset' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ExperimentalGroupByWindowDatasetInst {
    /// An instance of a fully built ExperimentalGroupByWindowDataset Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ExperimentalGroupByWindowDataset {
    /// Creates a new `ExperimentalGroupByWindowDataset`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `key_func` attribute.
    pub fn key_func<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.key_func = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `reduce_func` attribute.
    pub fn reduce_func<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.reduce_func = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `window_size_func` attribute.
    pub fn window_size_func<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.window_size_func = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tkey_func_other_arguments` attribute.
    pub fn Tkey_func_other_arguments<
        ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>,
    >(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tkey_func_other_arguments = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Treduce_func_other_arguments` attribute.
    pub fn Treduce_func_other_arguments<
        ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>,
    >(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Treduce_func_other_arguments = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Twindow_size_func_other_arguments` attribute.
    pub fn Twindow_size_func_other_arguments<
        ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>,
    >(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Twindow_size_func_other_arguments = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ExperimentalGroupByWindowDataset` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input_dataset: O0,
        key_func_other_arguments: O1,
        reduce_func_other_arguments: O2,
        window_size_func_other_arguments: O3,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            input_dataset.into(),
            key_func_other_arguments.into(),
            reduce_func_other_arguments.into(),
            window_size_func_other_arguments.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        input_dataset: crate::Output,
        key_func_other_arguments: crate::Output,
        reduce_func_other_arguments: crate::Output,
        window_size_func_other_arguments: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ExperimentalGroupByWindowDataset", |nd| {
            nd.add_input(input_dataset);
            nd.add_input(key_func_other_arguments);
            nd.add_input(reduce_func_other_arguments);
            nd.add_input(window_size_func_other_arguments);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.key_func {
                nd.set_attr_string("key_func", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.reduce_func {
                nd.set_attr_string("reduce_func", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.window_size_func {
                nd.set_attr_string("window_size_func", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tkey_func_other_arguments {
                nd.set_attr_type_list("Tkey_func_other_arguments", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Treduce_func_other_arguments {
                nd.set_attr_type_list("Treduce_func_other_arguments", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Twindow_size_func_other_arguments {
                nd.set_attr_type_list("Twindow_size_func_other_arguments", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ExperimentalGroupByWindowDataset' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_dataset: crate::Output,
        key_func_other_arguments: crate::Output,
        reduce_func_other_arguments: crate::Output,
        window_size_func_other_arguments: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ExperimentalGroupByWindowDatasetInst> {
        let op = scope.new_operation("ExperimentalGroupByWindowDataset", |builder| {
            builder.add_input(input_dataset);
            builder.add_input(key_func_other_arguments);
            builder.add_input(reduce_func_other_arguments);
            builder.add_input(window_size_func_other_arguments);
            if let ::std::option::Option::Some(value) = &self.key_func {
                builder.set_attr_string("key_func", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.reduce_func {
                builder.set_attr_string("reduce_func", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.window_size_func {
                builder.set_attr_string("window_size_func", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tkey_func_other_arguments {
                builder.set_attr_type_list("Tkey_func_other_arguments", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Treduce_func_other_arguments {
                builder.set_attr_type_list("Treduce_func_other_arguments", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Twindow_size_func_other_arguments {
                builder.set_attr_type_list("Twindow_size_func_other_arguments", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ExperimentalGroupByWindowDatasetInst { op })
    }
}
impl ExperimentalGroupByWindowDatasetInst {
    /// Returns the 'handle' Output of this 'ExperimentalGroupByWindowDataset' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_dataset' Input of this 'ExperimentalGroupByWindowDataset' operation.
    pub fn input_dataset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'key_func_other_arguments' Input of this 'ExperimentalGroupByWindowDataset' operation.
    pub fn key_func_other_arguments(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'reduce_func_other_arguments' Input of this 'ExperimentalGroupByWindowDataset' operation.
    pub fn reduce_func_other_arguments(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'window_size_func_other_arguments' Input of this 'ExperimentalGroupByWindowDataset' operation.
    pub fn window_size_func_other_arguments(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
}
impl From<ExperimentalGroupByWindowDatasetInst> for crate::Operation {
    fn from(inst: ExperimentalGroupByWindowDatasetInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ExperimentalGroupByWindowDataset::new().build(input_dataset, key_func_other_arguments, reduce_func_other_arguments, window_size_func_other_arguments, scope)`.
pub fn experimental_group_by_window_dataset<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
>(
    input_dataset: O0,
    key_func_other_arguments: O1,
    reduce_func_other_arguments: O2,
    window_size_func_other_arguments: O3,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ExperimentalGroupByWindowDataset::new().build(
        input_dataset,
        key_func_other_arguments,
        reduce_func_other_arguments,
        window_size_func_other_arguments,
        scope,
    )
}

/// Builder for the `ExperimentalIgnoreErrorsDataset` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ExperimentalIgnoreErrorsDataset {
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    log_warning: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ExperimentalIgnoreErrorsDataset' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ExperimentalIgnoreErrorsDatasetInst {
    /// An instance of a fully built ExperimentalIgnoreErrorsDataset Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ExperimentalIgnoreErrorsDataset {
    /// Creates a new `ExperimentalIgnoreErrorsDataset`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `log_warning` attribute.
    pub fn log_warning<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.log_warning = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ExperimentalIgnoreErrorsDataset` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input_dataset: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input_dataset.into(), scope)
    }
    fn build_impl(
        &self,
        input_dataset: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ExperimentalIgnoreErrorsDataset", |nd| {
            nd.add_input(input_dataset);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.log_warning {
                nd.set_attr_bool("log_warning", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ExperimentalIgnoreErrorsDataset' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_dataset: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ExperimentalIgnoreErrorsDatasetInst> {
        let op = scope.new_operation("ExperimentalIgnoreErrorsDataset", |builder| {
            builder.add_input(input_dataset);
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.log_warning {
                builder.set_attr_bool("log_warning", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ExperimentalIgnoreErrorsDatasetInst { op })
    }
}
impl ExperimentalIgnoreErrorsDatasetInst {
    /// Returns the 'handle' Output of this 'ExperimentalIgnoreErrorsDataset' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_dataset' Input of this 'ExperimentalIgnoreErrorsDataset' operation.
    pub fn input_dataset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<ExperimentalIgnoreErrorsDatasetInst> for crate::Operation {
    fn from(inst: ExperimentalIgnoreErrorsDatasetInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ExperimentalIgnoreErrorsDataset::new().build(input_dataset, scope)`.
pub fn experimental_ignore_errors_dataset<O0: ::std::convert::Into<crate::Output>>(
    input_dataset: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ExperimentalIgnoreErrorsDataset::new().build(input_dataset, scope)
}

/// Builder for the `ExperimentalIteratorGetDevice` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ExperimentalIteratorGetDevice {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ExperimentalIteratorGetDevice' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ExperimentalIteratorGetDeviceInst {
    /// An instance of a fully built ExperimentalIteratorGetDevice Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ExperimentalIteratorGetDevice {
    /// Creates a new `ExperimentalIteratorGetDevice`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ExperimentalIteratorGetDevice` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        resource: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(resource.into(), scope)
    }
    fn build_impl(
        &self,
        resource: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ExperimentalIteratorGetDevice", |nd| {
            nd.add_input(resource);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ExperimentalIteratorGetDevice' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        resource: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ExperimentalIteratorGetDeviceInst> {
        let op = scope.new_operation("ExperimentalIteratorGetDevice", |builder| {
            builder.add_input(resource);
            ::std::result::Result::Ok(())
        })?;
        Ok(ExperimentalIteratorGetDeviceInst { op })
    }
}
impl ExperimentalIteratorGetDeviceInst {
    /// Returns the 'device' Output of this 'ExperimentalIteratorGetDevice' operation.
    pub fn device(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'resource' Input of this 'ExperimentalIteratorGetDevice' operation.
    pub fn resource(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<ExperimentalIteratorGetDeviceInst> for crate::Operation {
    fn from(inst: ExperimentalIteratorGetDeviceInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ExperimentalIteratorGetDevice::new().build(resource, scope)`.
pub fn experimental_iterator_get_device<O0: ::std::convert::Into<crate::Output>>(
    resource: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ExperimentalIteratorGetDevice::new().build(resource, scope)
}

/// Builder for the `ExperimentalLMDBDataset` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ExperimentalLMDBDataset {
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ExperimentalLMDBDataset' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ExperimentalLMDBDatasetInst {
    /// An instance of a fully built ExperimentalLMDBDataset Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ExperimentalLMDBDataset {
    /// Creates a new `ExperimentalLMDBDataset`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ExperimentalLMDBDataset` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        filenames: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(filenames.into(), scope)
    }
    fn build_impl(
        &self,
        filenames: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ExperimentalLMDBDataset", |nd| {
            nd.add_input(filenames);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ExperimentalLMDBDataset' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        filenames: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ExperimentalLMDBDatasetInst> {
        let op = scope.new_operation("ExperimentalLMDBDataset", |builder| {
            builder.add_input(filenames);
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ExperimentalLMDBDatasetInst { op })
    }
}
impl ExperimentalLMDBDatasetInst {
    /// Returns the 'handle' Output of this 'ExperimentalLMDBDataset' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'filenames' Input of this 'ExperimentalLMDBDataset' operation.
    pub fn filenames(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<ExperimentalLMDBDatasetInst> for crate::Operation {
    fn from(inst: ExperimentalLMDBDatasetInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ExperimentalLMDBDataset::new().build(filenames, scope)`.
pub fn experimental_lmdbdataset<O0: ::std::convert::Into<crate::Output>>(
    filenames: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ExperimentalLMDBDataset::new().build(filenames, scope)
}

/// Builder for the `ExperimentalLatencyStatsDataset` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ExperimentalLatencyStatsDataset {
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ExperimentalLatencyStatsDataset' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ExperimentalLatencyStatsDatasetInst {
    /// An instance of a fully built ExperimentalLatencyStatsDataset Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ExperimentalLatencyStatsDataset {
    /// Creates a new `ExperimentalLatencyStatsDataset`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ExperimentalLatencyStatsDataset` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input_dataset: O0,
        tag: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input_dataset.into(), tag.into(), scope)
    }
    fn build_impl(
        &self,
        input_dataset: crate::Output,
        tag: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ExperimentalLatencyStatsDataset", |nd| {
            nd.add_input(input_dataset);
            nd.add_input(tag);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ExperimentalLatencyStatsDataset' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_dataset: crate::Output,
        tag: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ExperimentalLatencyStatsDatasetInst> {
        let op = scope.new_operation("ExperimentalLatencyStatsDataset", |builder| {
            builder.add_input(input_dataset);
            builder.add_input(tag);
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ExperimentalLatencyStatsDatasetInst { op })
    }
}
impl ExperimentalLatencyStatsDatasetInst {
    /// Returns the 'handle' Output of this 'ExperimentalLatencyStatsDataset' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_dataset' Input of this 'ExperimentalLatencyStatsDataset' operation.
    pub fn input_dataset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'tag' Input of this 'ExperimentalLatencyStatsDataset' operation.
    pub fn tag(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<ExperimentalLatencyStatsDatasetInst> for crate::Operation {
    fn from(inst: ExperimentalLatencyStatsDatasetInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ExperimentalLatencyStatsDataset::new().build(input_dataset, tag, scope)`.
pub fn experimental_latency_stats_dataset<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    input_dataset: O0,
    tag: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ExperimentalLatencyStatsDataset::new().build(input_dataset, tag, scope)
}

/// Builder for the `ExperimentalMapAndBatchDataset` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ExperimentalMapAndBatchDataset {
    f: ::std::option::Option<::std::string::String>,
    Targuments: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    preserve_cardinality: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ExperimentalMapAndBatchDataset' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ExperimentalMapAndBatchDatasetInst {
    /// An instance of a fully built ExperimentalMapAndBatchDataset Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ExperimentalMapAndBatchDataset {
    /// Creates a new `ExperimentalMapAndBatchDataset`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `f` attribute.
    pub fn f<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.f = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Targuments` attribute.
    pub fn Targuments<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Targuments = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `preserve_cardinality` attribute.
    pub fn preserve_cardinality<ArgType: ::std::convert::Into<bool>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.preserve_cardinality = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ExperimentalMapAndBatchDataset` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input_dataset: O0,
        other_arguments: O1,
        batch_size: O2,
        num_parallel_calls: O3,
        drop_remainder: O4,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            input_dataset.into(),
            other_arguments.into(),
            batch_size.into(),
            num_parallel_calls.into(),
            drop_remainder.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        input_dataset: crate::Output,
        other_arguments: crate::Output,
        batch_size: crate::Output,
        num_parallel_calls: crate::Output,
        drop_remainder: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ExperimentalMapAndBatchDataset", |nd| {
            nd.add_input(input_dataset);
            nd.add_input(other_arguments);
            nd.add_input(batch_size);
            nd.add_input(num_parallel_calls);
            nd.add_input(drop_remainder);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.f {
                nd.set_attr_string("f", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Targuments {
                nd.set_attr_type_list("Targuments", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.preserve_cardinality {
                nd.set_attr_bool("preserve_cardinality", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ExperimentalMapAndBatchDataset' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_dataset: crate::Output,
        other_arguments: crate::Output,
        batch_size: crate::Output,
        num_parallel_calls: crate::Output,
        drop_remainder: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ExperimentalMapAndBatchDatasetInst> {
        let op = scope.new_operation("ExperimentalMapAndBatchDataset", |builder| {
            builder.add_input(input_dataset);
            builder.add_input(other_arguments);
            builder.add_input(batch_size);
            builder.add_input(num_parallel_calls);
            builder.add_input(drop_remainder);
            if let ::std::option::Option::Some(value) = &self.f {
                builder.set_attr_string("f", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Targuments {
                builder.set_attr_type_list("Targuments", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.preserve_cardinality {
                builder.set_attr_bool("preserve_cardinality", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ExperimentalMapAndBatchDatasetInst { op })
    }
}
impl ExperimentalMapAndBatchDatasetInst {
    /// Returns the 'handle' Output of this 'ExperimentalMapAndBatchDataset' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_dataset' Input of this 'ExperimentalMapAndBatchDataset' operation.
    pub fn input_dataset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'other_arguments' Input of this 'ExperimentalMapAndBatchDataset' operation.
    pub fn other_arguments(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'batch_size' Input of this 'ExperimentalMapAndBatchDataset' operation.
    pub fn batch_size(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'num_parallel_calls' Input of this 'ExperimentalMapAndBatchDataset' operation.
    pub fn num_parallel_calls(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'drop_remainder' Input of this 'ExperimentalMapAndBatchDataset' operation.
    pub fn drop_remainder(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
}
impl From<ExperimentalMapAndBatchDatasetInst> for crate::Operation {
    fn from(inst: ExperimentalMapAndBatchDatasetInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ExperimentalMapAndBatchDataset::new().build(input_dataset, other_arguments, batch_size, num_parallel_calls, drop_remainder, scope)`.
pub fn experimental_map_and_batch_dataset<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
>(
    input_dataset: O0,
    other_arguments: O1,
    batch_size: O2,
    num_parallel_calls: O3,
    drop_remainder: O4,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ExperimentalMapAndBatchDataset::new().build(
        input_dataset,
        other_arguments,
        batch_size,
        num_parallel_calls,
        drop_remainder,
        scope,
    )
}

/// Builder for the `ExperimentalMapDataset` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ExperimentalMapDataset {
    f: ::std::option::Option<::std::string::String>,
    Targuments: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    use_inter_op_parallelism: ::std::option::Option<bool>,
    preserve_cardinality: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ExperimentalMapDataset' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ExperimentalMapDatasetInst {
    /// An instance of a fully built ExperimentalMapDataset Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ExperimentalMapDataset {
    /// Creates a new `ExperimentalMapDataset`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `f` attribute.
    pub fn f<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.f = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Targuments` attribute.
    pub fn Targuments<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Targuments = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_inter_op_parallelism` attribute.
    pub fn use_inter_op_parallelism<ArgType: ::std::convert::Into<bool>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.use_inter_op_parallelism = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `preserve_cardinality` attribute.
    pub fn preserve_cardinality<ArgType: ::std::convert::Into<bool>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.preserve_cardinality = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ExperimentalMapDataset` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input_dataset: O0,
        other_arguments: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input_dataset.into(), other_arguments.into(), scope)
    }
    fn build_impl(
        &self,
        input_dataset: crate::Output,
        other_arguments: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ExperimentalMapDataset", |nd| {
            nd.add_input(input_dataset);
            nd.add_input(other_arguments);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.f {
                nd.set_attr_string("f", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Targuments {
                nd.set_attr_type_list("Targuments", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_inter_op_parallelism {
                nd.set_attr_bool("use_inter_op_parallelism", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.preserve_cardinality {
                nd.set_attr_bool("preserve_cardinality", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ExperimentalMapDataset' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_dataset: crate::Output,
        other_arguments: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ExperimentalMapDatasetInst> {
        let op = scope.new_operation("ExperimentalMapDataset", |builder| {
            builder.add_input(input_dataset);
            builder.add_input(other_arguments);
            if let ::std::option::Option::Some(value) = &self.f {
                builder.set_attr_string("f", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Targuments {
                builder.set_attr_type_list("Targuments", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_inter_op_parallelism {
                builder.set_attr_bool("use_inter_op_parallelism", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.preserve_cardinality {
                builder.set_attr_bool("preserve_cardinality", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ExperimentalMapDatasetInst { op })
    }
}
impl ExperimentalMapDatasetInst {
    /// Returns the 'handle' Output of this 'ExperimentalMapDataset' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_dataset' Input of this 'ExperimentalMapDataset' operation.
    pub fn input_dataset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'other_arguments' Input of this 'ExperimentalMapDataset' operation.
    pub fn other_arguments(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<ExperimentalMapDatasetInst> for crate::Operation {
    fn from(inst: ExperimentalMapDatasetInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ExperimentalMapDataset::new().build(input_dataset, other_arguments, scope)`.
pub fn experimental_map_dataset<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    input_dataset: O0,
    other_arguments: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ExperimentalMapDataset::new().build(input_dataset, other_arguments, scope)
}

/// Builder for the `ExperimentalMatchingFilesDataset` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ExperimentalMatchingFilesDataset {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ExperimentalMatchingFilesDataset' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ExperimentalMatchingFilesDatasetInst {
    /// An instance of a fully built ExperimentalMatchingFilesDataset Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ExperimentalMatchingFilesDataset {
    /// Creates a new `ExperimentalMatchingFilesDataset`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ExperimentalMatchingFilesDataset` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        patterns: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(patterns.into(), scope)
    }
    fn build_impl(
        &self,
        patterns: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ExperimentalMatchingFilesDataset", |nd| {
            nd.add_input(patterns);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ExperimentalMatchingFilesDataset' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        patterns: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ExperimentalMatchingFilesDatasetInst> {
        let op = scope.new_operation("ExperimentalMatchingFilesDataset", |builder| {
            builder.add_input(patterns);
            ::std::result::Result::Ok(())
        })?;
        Ok(ExperimentalMatchingFilesDatasetInst { op })
    }
}
impl ExperimentalMatchingFilesDatasetInst {
    /// Returns the 'handle' Output of this 'ExperimentalMatchingFilesDataset' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'patterns' Input of this 'ExperimentalMatchingFilesDataset' operation.
    pub fn patterns(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<ExperimentalMatchingFilesDatasetInst> for crate::Operation {
    fn from(inst: ExperimentalMatchingFilesDatasetInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ExperimentalMatchingFilesDataset::new().build(patterns, scope)`.
pub fn experimental_matching_files_dataset<O0: ::std::convert::Into<crate::Output>>(
    patterns: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ExperimentalMatchingFilesDataset::new().build(patterns, scope)
}

/// Builder for the `ExperimentalMaxIntraOpParallelismDataset` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ExperimentalMaxIntraOpParallelismDataset {
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ExperimentalMaxIntraOpParallelismDataset' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ExperimentalMaxIntraOpParallelismDatasetInst {
    /// An instance of a fully built ExperimentalMaxIntraOpParallelismDataset Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ExperimentalMaxIntraOpParallelismDataset {
    /// Creates a new `ExperimentalMaxIntraOpParallelismDataset`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ExperimentalMaxIntraOpParallelismDataset` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input_dataset: O0,
        max_intra_op_parallelism: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input_dataset.into(), max_intra_op_parallelism.into(), scope)
    }
    fn build_impl(
        &self,
        input_dataset: crate::Output,
        max_intra_op_parallelism: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ExperimentalMaxIntraOpParallelismDataset", |nd| {
            nd.add_input(input_dataset);
            nd.add_input(max_intra_op_parallelism);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ExperimentalMaxIntraOpParallelismDataset' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_dataset: crate::Output,
        max_intra_op_parallelism: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ExperimentalMaxIntraOpParallelismDatasetInst> {
        let op = scope.new_operation("ExperimentalMaxIntraOpParallelismDataset", |builder| {
            builder.add_input(input_dataset);
            builder.add_input(max_intra_op_parallelism);
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ExperimentalMaxIntraOpParallelismDatasetInst { op })
    }
}
impl ExperimentalMaxIntraOpParallelismDatasetInst {
    /// Returns the 'handle' Output of this 'ExperimentalMaxIntraOpParallelismDataset' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_dataset' Input of this 'ExperimentalMaxIntraOpParallelismDataset' operation.
    pub fn input_dataset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'max_intra_op_parallelism' Input of this 'ExperimentalMaxIntraOpParallelismDataset' operation.
    pub fn max_intra_op_parallelism(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<ExperimentalMaxIntraOpParallelismDatasetInst> for crate::Operation {
    fn from(inst: ExperimentalMaxIntraOpParallelismDatasetInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ExperimentalMaxIntraOpParallelismDataset::new().build(input_dataset, max_intra_op_parallelism, scope)`.
pub fn experimental_max_intra_op_parallelism_dataset<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    input_dataset: O0,
    max_intra_op_parallelism: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ExperimentalMaxIntraOpParallelismDataset::new().build(
        input_dataset,
        max_intra_op_parallelism,
        scope,
    )
}

/// Builder for the `ExperimentalNonSerializableDataset` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ExperimentalNonSerializableDataset {
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ExperimentalNonSerializableDataset' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ExperimentalNonSerializableDatasetInst {
    /// An instance of a fully built ExperimentalNonSerializableDataset Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ExperimentalNonSerializableDataset {
    /// Creates a new `ExperimentalNonSerializableDataset`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ExperimentalNonSerializableDataset` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input_dataset: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input_dataset.into(), scope)
    }
    fn build_impl(
        &self,
        input_dataset: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ExperimentalNonSerializableDataset", |nd| {
            nd.add_input(input_dataset);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ExperimentalNonSerializableDataset' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_dataset: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ExperimentalNonSerializableDatasetInst> {
        let op = scope.new_operation("ExperimentalNonSerializableDataset", |builder| {
            builder.add_input(input_dataset);
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ExperimentalNonSerializableDatasetInst { op })
    }
}
impl ExperimentalNonSerializableDatasetInst {
    /// Returns the 'handle' Output of this 'ExperimentalNonSerializableDataset' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_dataset' Input of this 'ExperimentalNonSerializableDataset' operation.
    pub fn input_dataset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<ExperimentalNonSerializableDatasetInst> for crate::Operation {
    fn from(inst: ExperimentalNonSerializableDatasetInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ExperimentalNonSerializableDataset::new().build(input_dataset, scope)`.
pub fn experimental_non_serializable_dataset<O0: ::std::convert::Into<crate::Output>>(
    input_dataset: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ExperimentalNonSerializableDataset::new().build(input_dataset, scope)
}

/// Builder for the `ExperimentalParallelInterleaveDataset` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ExperimentalParallelInterleaveDataset {
    f: ::std::option::Option<::std::string::String>,
    Targuments: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ExperimentalParallelInterleaveDataset' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ExperimentalParallelInterleaveDatasetInst {
    /// An instance of a fully built ExperimentalParallelInterleaveDataset Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ExperimentalParallelInterleaveDataset {
    /// Creates a new `ExperimentalParallelInterleaveDataset`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `f` attribute.
    pub fn f<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.f = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Targuments` attribute.
    pub fn Targuments<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Targuments = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ExperimentalParallelInterleaveDataset` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
        O6: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input_dataset: O0,
        other_arguments: O1,
        cycle_length: O2,
        block_length: O3,
        sloppy: O4,
        buffer_output_elements: O5,
        prefetch_input_elements: O6,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            input_dataset.into(),
            other_arguments.into(),
            cycle_length.into(),
            block_length.into(),
            sloppy.into(),
            buffer_output_elements.into(),
            prefetch_input_elements.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        input_dataset: crate::Output,
        other_arguments: crate::Output,
        cycle_length: crate::Output,
        block_length: crate::Output,
        sloppy: crate::Output,
        buffer_output_elements: crate::Output,
        prefetch_input_elements: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ExperimentalParallelInterleaveDataset", |nd| {
            nd.add_input(input_dataset);
            nd.add_input(other_arguments);
            nd.add_input(cycle_length);
            nd.add_input(block_length);
            nd.add_input(sloppy);
            nd.add_input(buffer_output_elements);
            nd.add_input(prefetch_input_elements);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.f {
                nd.set_attr_string("f", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Targuments {
                nd.set_attr_type_list("Targuments", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ExperimentalParallelInterleaveDataset' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_dataset: crate::Output,
        other_arguments: crate::Output,
        cycle_length: crate::Output,
        block_length: crate::Output,
        sloppy: crate::Output,
        buffer_output_elements: crate::Output,
        prefetch_input_elements: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ExperimentalParallelInterleaveDatasetInst> {
        let op = scope.new_operation("ExperimentalParallelInterleaveDataset", |builder| {
            builder.add_input(input_dataset);
            builder.add_input(other_arguments);
            builder.add_input(cycle_length);
            builder.add_input(block_length);
            builder.add_input(sloppy);
            builder.add_input(buffer_output_elements);
            builder.add_input(prefetch_input_elements);
            if let ::std::option::Option::Some(value) = &self.f {
                builder.set_attr_string("f", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Targuments {
                builder.set_attr_type_list("Targuments", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ExperimentalParallelInterleaveDatasetInst { op })
    }
}
impl ExperimentalParallelInterleaveDatasetInst {
    /// Returns the 'handle' Output of this 'ExperimentalParallelInterleaveDataset' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_dataset' Input of this 'ExperimentalParallelInterleaveDataset' operation.
    pub fn input_dataset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'other_arguments' Input of this 'ExperimentalParallelInterleaveDataset' operation.
    pub fn other_arguments(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'cycle_length' Input of this 'ExperimentalParallelInterleaveDataset' operation.
    pub fn cycle_length(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'block_length' Input of this 'ExperimentalParallelInterleaveDataset' operation.
    pub fn block_length(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'sloppy' Input of this 'ExperimentalParallelInterleaveDataset' operation.
    pub fn sloppy(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
    /// Returns the 'buffer_output_elements' Input of this 'ExperimentalParallelInterleaveDataset' operation.
    pub fn buffer_output_elements(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 5,
        }
    }
    /// Returns the 'prefetch_input_elements' Input of this 'ExperimentalParallelInterleaveDataset' operation.
    pub fn prefetch_input_elements(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 6,
        }
    }
}
impl From<ExperimentalParallelInterleaveDatasetInst> for crate::Operation {
    fn from(inst: ExperimentalParallelInterleaveDatasetInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ExperimentalParallelInterleaveDataset::new().build(input_dataset, other_arguments, cycle_length, block_length, sloppy, buffer_output_elements, prefetch_input_elements, scope)`.
pub fn experimental_parallel_interleave_dataset<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
    O6: ::std::convert::Into<crate::Output>,
>(
    input_dataset: O0,
    other_arguments: O1,
    cycle_length: O2,
    block_length: O3,
    sloppy: O4,
    buffer_output_elements: O5,
    prefetch_input_elements: O6,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ExperimentalParallelInterleaveDataset::new().build(
        input_dataset,
        other_arguments,
        cycle_length,
        block_length,
        sloppy,
        buffer_output_elements,
        prefetch_input_elements,
        scope,
    )
}

/// Builder for the `ExperimentalParseExampleDataset` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ExperimentalParseExampleDataset {
    sparse_keys: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
    dense_keys: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
    sparse_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    Tdense: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    dense_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    sloppy: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ExperimentalParseExampleDataset' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ExperimentalParseExampleDatasetInst {
    /// An instance of a fully built ExperimentalParseExampleDataset Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ExperimentalParseExampleDataset {
    /// Creates a new `ExperimentalParseExampleDataset`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `sparse_keys` attribute.
    pub fn sparse_keys<ArgType: ::std::convert::Into<::std::vec::Vec<::std::string::String>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.sparse_keys = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `dense_keys` attribute.
    pub fn dense_keys<ArgType: ::std::convert::Into<::std::vec::Vec<::std::string::String>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.dense_keys = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `sparse_types` attribute.
    pub fn sparse_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.sparse_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tdense` attribute.
    pub fn Tdense<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tdense = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `dense_shapes` attribute.
    pub fn dense_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.dense_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `sloppy` attribute.
    pub fn sloppy<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.sloppy = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ExperimentalParseExampleDataset` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input_dataset: O0,
        num_parallel_calls: O1,
        dense_defaults: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            input_dataset.into(),
            num_parallel_calls.into(),
            dense_defaults.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        input_dataset: crate::Output,
        num_parallel_calls: crate::Output,
        dense_defaults: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ExperimentalParseExampleDataset", |nd| {
            nd.add_input(input_dataset);
            nd.add_input(num_parallel_calls);
            nd.add_input(dense_defaults);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.sparse_keys {
                nd.set_attr_string_list("sparse_keys", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dense_keys {
                nd.set_attr_string_list("dense_keys", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.sparse_types {
                nd.set_attr_type_list("sparse_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tdense {
                nd.set_attr_type_list("Tdense", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dense_shapes {
                nd.set_attr_shape_list("dense_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.sloppy {
                nd.set_attr_bool("sloppy", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ExperimentalParseExampleDataset' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_dataset: crate::Output,
        num_parallel_calls: crate::Output,
        dense_defaults: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ExperimentalParseExampleDatasetInst> {
        let op = scope.new_operation("ExperimentalParseExampleDataset", |builder| {
            builder.add_input(input_dataset);
            builder.add_input(num_parallel_calls);
            builder.add_input(dense_defaults);
            if let ::std::option::Option::Some(value) = &self.sparse_keys {
                builder.set_attr_string_list("sparse_keys", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dense_keys {
                builder.set_attr_string_list("dense_keys", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.sparse_types {
                builder.set_attr_type_list("sparse_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tdense {
                builder.set_attr_type_list("Tdense", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dense_shapes {
                builder.set_attr_shape_list("dense_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.sloppy {
                builder.set_attr_bool("sloppy", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ExperimentalParseExampleDatasetInst { op })
    }
}
impl ExperimentalParseExampleDatasetInst {
    /// Returns the 'handle' Output of this 'ExperimentalParseExampleDataset' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_dataset' Input of this 'ExperimentalParseExampleDataset' operation.
    pub fn input_dataset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'num_parallel_calls' Input of this 'ExperimentalParseExampleDataset' operation.
    pub fn num_parallel_calls(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'dense_defaults' Input of this 'ExperimentalParseExampleDataset' operation.
    pub fn dense_defaults(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<ExperimentalParseExampleDatasetInst> for crate::Operation {
    fn from(inst: ExperimentalParseExampleDatasetInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ExperimentalParseExampleDataset::new().build(input_dataset, num_parallel_calls, dense_defaults, scope)`.
pub fn experimental_parse_example_dataset<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    input_dataset: O0,
    num_parallel_calls: O1,
    dense_defaults: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ExperimentalParseExampleDataset::new().build(
        input_dataset,
        num_parallel_calls,
        dense_defaults,
        scope,
    )
}

/// Builder for the `ExperimentalPrivateThreadPoolDataset` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ExperimentalPrivateThreadPoolDataset {
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ExperimentalPrivateThreadPoolDataset' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ExperimentalPrivateThreadPoolDatasetInst {
    /// An instance of a fully built ExperimentalPrivateThreadPoolDataset Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ExperimentalPrivateThreadPoolDataset {
    /// Creates a new `ExperimentalPrivateThreadPoolDataset`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ExperimentalPrivateThreadPoolDataset` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input_dataset: O0,
        num_threads: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input_dataset.into(), num_threads.into(), scope)
    }
    fn build_impl(
        &self,
        input_dataset: crate::Output,
        num_threads: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ExperimentalPrivateThreadPoolDataset", |nd| {
            nd.add_input(input_dataset);
            nd.add_input(num_threads);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ExperimentalPrivateThreadPoolDataset' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_dataset: crate::Output,
        num_threads: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ExperimentalPrivateThreadPoolDatasetInst> {
        let op = scope.new_operation("ExperimentalPrivateThreadPoolDataset", |builder| {
            builder.add_input(input_dataset);
            builder.add_input(num_threads);
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ExperimentalPrivateThreadPoolDatasetInst { op })
    }
}
impl ExperimentalPrivateThreadPoolDatasetInst {
    /// Returns the 'handle' Output of this 'ExperimentalPrivateThreadPoolDataset' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_dataset' Input of this 'ExperimentalPrivateThreadPoolDataset' operation.
    pub fn input_dataset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'num_threads' Input of this 'ExperimentalPrivateThreadPoolDataset' operation.
    pub fn num_threads(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<ExperimentalPrivateThreadPoolDatasetInst> for crate::Operation {
    fn from(inst: ExperimentalPrivateThreadPoolDatasetInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ExperimentalPrivateThreadPoolDataset::new().build(input_dataset, num_threads, scope)`.
pub fn experimental_private_thread_pool_dataset<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    input_dataset: O0,
    num_threads: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ExperimentalPrivateThreadPoolDataset::new().build(input_dataset, num_threads, scope)
}

/// Builder for the `ExperimentalRandomDataset` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ExperimentalRandomDataset {
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ExperimentalRandomDataset' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ExperimentalRandomDatasetInst {
    /// An instance of a fully built ExperimentalRandomDataset Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ExperimentalRandomDataset {
    /// Creates a new `ExperimentalRandomDataset`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ExperimentalRandomDataset` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        seed: O0,
        seed2: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(seed.into(), seed2.into(), scope)
    }
    fn build_impl(
        &self,
        seed: crate::Output,
        seed2: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ExperimentalRandomDataset", |nd| {
            nd.add_input(seed);
            nd.add_input(seed2);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ExperimentalRandomDataset' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        seed: crate::Output,
        seed2: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ExperimentalRandomDatasetInst> {
        let op = scope.new_operation("ExperimentalRandomDataset", |builder| {
            builder.add_input(seed);
            builder.add_input(seed2);
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ExperimentalRandomDatasetInst { op })
    }
}
impl ExperimentalRandomDatasetInst {
    /// Returns the 'handle' Output of this 'ExperimentalRandomDataset' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'seed' Input of this 'ExperimentalRandomDataset' operation.
    pub fn seed(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'seed2' Input of this 'ExperimentalRandomDataset' operation.
    pub fn seed2(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<ExperimentalRandomDatasetInst> for crate::Operation {
    fn from(inst: ExperimentalRandomDatasetInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ExperimentalRandomDataset::new().build(seed, seed2, scope)`.
pub fn experimental_random_dataset<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    seed: O0,
    seed2: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ExperimentalRandomDataset::new().build(seed, seed2, scope)
}

/// Builder for the `ExperimentalRebatchDataset` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ExperimentalRebatchDataset {
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    use_fallback: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ExperimentalRebatchDataset' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ExperimentalRebatchDatasetInst {
    /// An instance of a fully built ExperimentalRebatchDataset Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ExperimentalRebatchDataset {
    /// Creates a new `ExperimentalRebatchDataset`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_fallback` attribute.
    pub fn use_fallback<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.use_fallback = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ExperimentalRebatchDataset` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input_dataset: O0,
        num_replicas: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input_dataset.into(), num_replicas.into(), scope)
    }
    fn build_impl(
        &self,
        input_dataset: crate::Output,
        num_replicas: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ExperimentalRebatchDataset", |nd| {
            nd.add_input(input_dataset);
            nd.add_input(num_replicas);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_fallback {
                nd.set_attr_bool("use_fallback", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ExperimentalRebatchDataset' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_dataset: crate::Output,
        num_replicas: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ExperimentalRebatchDatasetInst> {
        let op = scope.new_operation("ExperimentalRebatchDataset", |builder| {
            builder.add_input(input_dataset);
            builder.add_input(num_replicas);
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_fallback {
                builder.set_attr_bool("use_fallback", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ExperimentalRebatchDatasetInst { op })
    }
}
impl ExperimentalRebatchDatasetInst {
    /// Returns the 'handle' Output of this 'ExperimentalRebatchDataset' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_dataset' Input of this 'ExperimentalRebatchDataset' operation.
    pub fn input_dataset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'num_replicas' Input of this 'ExperimentalRebatchDataset' operation.
    pub fn num_replicas(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<ExperimentalRebatchDatasetInst> for crate::Operation {
    fn from(inst: ExperimentalRebatchDatasetInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ExperimentalRebatchDataset::new().build(input_dataset, num_replicas, scope)`.
pub fn experimental_rebatch_dataset<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    input_dataset: O0,
    num_replicas: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ExperimentalRebatchDataset::new().build(input_dataset, num_replicas, scope)
}

/// Builder for the `ExperimentalScanDataset` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ExperimentalScanDataset {
    f: ::std::option::Option<::std::string::String>,
    Tstate: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    Targuments: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    preserve_cardinality: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ExperimentalScanDataset' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ExperimentalScanDatasetInst {
    /// An instance of a fully built ExperimentalScanDataset Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ExperimentalScanDataset {
    /// Creates a new `ExperimentalScanDataset`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `f` attribute.
    pub fn f<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.f = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tstate` attribute.
    pub fn Tstate<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tstate = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Targuments` attribute.
    pub fn Targuments<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Targuments = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `preserve_cardinality` attribute.
    pub fn preserve_cardinality<ArgType: ::std::convert::Into<bool>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.preserve_cardinality = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ExperimentalScanDataset` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input_dataset: O0,
        initial_state: O1,
        other_arguments: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            input_dataset.into(),
            initial_state.into(),
            other_arguments.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        input_dataset: crate::Output,
        initial_state: crate::Output,
        other_arguments: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ExperimentalScanDataset", |nd| {
            nd.add_input(input_dataset);
            nd.add_input(initial_state);
            nd.add_input(other_arguments);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.f {
                nd.set_attr_string("f", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tstate {
                nd.set_attr_type_list("Tstate", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Targuments {
                nd.set_attr_type_list("Targuments", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.preserve_cardinality {
                nd.set_attr_bool("preserve_cardinality", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ExperimentalScanDataset' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_dataset: crate::Output,
        initial_state: crate::Output,
        other_arguments: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ExperimentalScanDatasetInst> {
        let op = scope.new_operation("ExperimentalScanDataset", |builder| {
            builder.add_input(input_dataset);
            builder.add_input(initial_state);
            builder.add_input(other_arguments);
            if let ::std::option::Option::Some(value) = &self.f {
                builder.set_attr_string("f", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tstate {
                builder.set_attr_type_list("Tstate", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Targuments {
                builder.set_attr_type_list("Targuments", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.preserve_cardinality {
                builder.set_attr_bool("preserve_cardinality", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ExperimentalScanDatasetInst { op })
    }
}
impl ExperimentalScanDatasetInst {
    /// Returns the 'handle' Output of this 'ExperimentalScanDataset' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_dataset' Input of this 'ExperimentalScanDataset' operation.
    pub fn input_dataset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'initial_state' Input of this 'ExperimentalScanDataset' operation.
    pub fn initial_state(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'other_arguments' Input of this 'ExperimentalScanDataset' operation.
    pub fn other_arguments(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<ExperimentalScanDatasetInst> for crate::Operation {
    fn from(inst: ExperimentalScanDatasetInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ExperimentalScanDataset::new().build(input_dataset, initial_state, other_arguments, scope)`.
pub fn experimental_scan_dataset<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    input_dataset: O0,
    initial_state: O1,
    other_arguments: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ExperimentalScanDataset::new().build(input_dataset, initial_state, other_arguments, scope)
}

/// Builder for the `ExperimentalSetStatsAggregatorDataset` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ExperimentalSetStatsAggregatorDataset {
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ExperimentalSetStatsAggregatorDataset' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ExperimentalSetStatsAggregatorDatasetInst {
    /// An instance of a fully built ExperimentalSetStatsAggregatorDataset Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ExperimentalSetStatsAggregatorDataset {
    /// Creates a new `ExperimentalSetStatsAggregatorDataset`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ExperimentalSetStatsAggregatorDataset` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input_dataset: O0,
        stats_aggregator: O1,
        tag: O2,
        counter_prefix: O3,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            input_dataset.into(),
            stats_aggregator.into(),
            tag.into(),
            counter_prefix.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        input_dataset: crate::Output,
        stats_aggregator: crate::Output,
        tag: crate::Output,
        counter_prefix: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ExperimentalSetStatsAggregatorDataset", |nd| {
            nd.add_input(input_dataset);
            nd.add_input(stats_aggregator);
            nd.add_input(tag);
            nd.add_input(counter_prefix);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ExperimentalSetStatsAggregatorDataset' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_dataset: crate::Output,
        stats_aggregator: crate::Output,
        tag: crate::Output,
        counter_prefix: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ExperimentalSetStatsAggregatorDatasetInst> {
        let op = scope.new_operation("ExperimentalSetStatsAggregatorDataset", |builder| {
            builder.add_input(input_dataset);
            builder.add_input(stats_aggregator);
            builder.add_input(tag);
            builder.add_input(counter_prefix);
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ExperimentalSetStatsAggregatorDatasetInst { op })
    }
}
impl ExperimentalSetStatsAggregatorDatasetInst {
    /// Returns the 'handle' Output of this 'ExperimentalSetStatsAggregatorDataset' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_dataset' Input of this 'ExperimentalSetStatsAggregatorDataset' operation.
    pub fn input_dataset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'stats_aggregator' Input of this 'ExperimentalSetStatsAggregatorDataset' operation.
    pub fn stats_aggregator(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'tag' Input of this 'ExperimentalSetStatsAggregatorDataset' operation.
    pub fn tag(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'counter_prefix' Input of this 'ExperimentalSetStatsAggregatorDataset' operation.
    pub fn counter_prefix(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
}
impl From<ExperimentalSetStatsAggregatorDatasetInst> for crate::Operation {
    fn from(inst: ExperimentalSetStatsAggregatorDatasetInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ExperimentalSetStatsAggregatorDataset::new().build(input_dataset, stats_aggregator, tag, counter_prefix, scope)`.
pub fn experimental_set_stats_aggregator_dataset<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
>(
    input_dataset: O0,
    stats_aggregator: O1,
    tag: O2,
    counter_prefix: O3,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ExperimentalSetStatsAggregatorDataset::new().build(
        input_dataset,
        stats_aggregator,
        tag,
        counter_prefix,
        scope,
    )
}

/// Builder for the `ExperimentalSleepDataset` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ExperimentalSleepDataset {
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ExperimentalSleepDataset' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ExperimentalSleepDatasetInst {
    /// An instance of a fully built ExperimentalSleepDataset Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ExperimentalSleepDataset {
    /// Creates a new `ExperimentalSleepDataset`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ExperimentalSleepDataset` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input_dataset: O0,
        sleep_microseconds: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input_dataset.into(), sleep_microseconds.into(), scope)
    }
    fn build_impl(
        &self,
        input_dataset: crate::Output,
        sleep_microseconds: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ExperimentalSleepDataset", |nd| {
            nd.add_input(input_dataset);
            nd.add_input(sleep_microseconds);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ExperimentalSleepDataset' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_dataset: crate::Output,
        sleep_microseconds: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ExperimentalSleepDatasetInst> {
        let op = scope.new_operation("ExperimentalSleepDataset", |builder| {
            builder.add_input(input_dataset);
            builder.add_input(sleep_microseconds);
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ExperimentalSleepDatasetInst { op })
    }
}
impl ExperimentalSleepDatasetInst {
    /// Returns the 'handle' Output of this 'ExperimentalSleepDataset' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_dataset' Input of this 'ExperimentalSleepDataset' operation.
    pub fn input_dataset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'sleep_microseconds' Input of this 'ExperimentalSleepDataset' operation.
    pub fn sleep_microseconds(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<ExperimentalSleepDatasetInst> for crate::Operation {
    fn from(inst: ExperimentalSleepDatasetInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ExperimentalSleepDataset::new().build(input_dataset, sleep_microseconds, scope)`.
pub fn experimental_sleep_dataset<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    input_dataset: O0,
    sleep_microseconds: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ExperimentalSleepDataset::new().build(input_dataset, sleep_microseconds, scope)
}

/// Builder for the `ExperimentalSlidingWindowDataset` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ExperimentalSlidingWindowDataset {
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ExperimentalSlidingWindowDataset' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ExperimentalSlidingWindowDatasetInst {
    /// An instance of a fully built ExperimentalSlidingWindowDataset Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ExperimentalSlidingWindowDataset {
    /// Creates a new `ExperimentalSlidingWindowDataset`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ExperimentalSlidingWindowDataset` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input_dataset: O0,
        window_size: O1,
        window_shift: O2,
        window_stride: O3,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            input_dataset.into(),
            window_size.into(),
            window_shift.into(),
            window_stride.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        input_dataset: crate::Output,
        window_size: crate::Output,
        window_shift: crate::Output,
        window_stride: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ExperimentalSlidingWindowDataset", |nd| {
            nd.add_input(input_dataset);
            nd.add_input(window_size);
            nd.add_input(window_shift);
            nd.add_input(window_stride);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ExperimentalSlidingWindowDataset' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_dataset: crate::Output,
        window_size: crate::Output,
        window_shift: crate::Output,
        window_stride: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ExperimentalSlidingWindowDatasetInst> {
        let op = scope.new_operation("ExperimentalSlidingWindowDataset", |builder| {
            builder.add_input(input_dataset);
            builder.add_input(window_size);
            builder.add_input(window_shift);
            builder.add_input(window_stride);
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ExperimentalSlidingWindowDatasetInst { op })
    }
}
impl ExperimentalSlidingWindowDatasetInst {
    /// Returns the 'handle' Output of this 'ExperimentalSlidingWindowDataset' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_dataset' Input of this 'ExperimentalSlidingWindowDataset' operation.
    pub fn input_dataset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'window_size' Input of this 'ExperimentalSlidingWindowDataset' operation.
    pub fn window_size(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'window_shift' Input of this 'ExperimentalSlidingWindowDataset' operation.
    pub fn window_shift(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'window_stride' Input of this 'ExperimentalSlidingWindowDataset' operation.
    pub fn window_stride(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
}
impl From<ExperimentalSlidingWindowDatasetInst> for crate::Operation {
    fn from(inst: ExperimentalSlidingWindowDatasetInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ExperimentalSlidingWindowDataset::new().build(input_dataset, window_size, window_shift, window_stride, scope)`.
pub fn experimental_sliding_window_dataset<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
>(
    input_dataset: O0,
    window_size: O1,
    window_shift: O2,
    window_stride: O3,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ExperimentalSlidingWindowDataset::new().build(
        input_dataset,
        window_size,
        window_shift,
        window_stride,
        scope,
    )
}

/// Builder for the `ExperimentalSqlDataset` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ExperimentalSqlDataset {
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ExperimentalSqlDataset' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ExperimentalSqlDatasetInst {
    /// An instance of a fully built ExperimentalSqlDataset Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ExperimentalSqlDataset {
    /// Creates a new `ExperimentalSqlDataset`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ExperimentalSqlDataset` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        driver_name: O0,
        data_source_name: O1,
        query: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            driver_name.into(),
            data_source_name.into(),
            query.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        driver_name: crate::Output,
        data_source_name: crate::Output,
        query: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ExperimentalSqlDataset", |nd| {
            nd.add_input(driver_name);
            nd.add_input(data_source_name);
            nd.add_input(query);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ExperimentalSqlDataset' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        driver_name: crate::Output,
        data_source_name: crate::Output,
        query: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ExperimentalSqlDatasetInst> {
        let op = scope.new_operation("ExperimentalSqlDataset", |builder| {
            builder.add_input(driver_name);
            builder.add_input(data_source_name);
            builder.add_input(query);
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ExperimentalSqlDatasetInst { op })
    }
}
impl ExperimentalSqlDatasetInst {
    /// Returns the 'handle' Output of this 'ExperimentalSqlDataset' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'driver_name' Input of this 'ExperimentalSqlDataset' operation.
    pub fn driver_name(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'data_source_name' Input of this 'ExperimentalSqlDataset' operation.
    pub fn data_source_name(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'query' Input of this 'ExperimentalSqlDataset' operation.
    pub fn query(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<ExperimentalSqlDatasetInst> for crate::Operation {
    fn from(inst: ExperimentalSqlDatasetInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ExperimentalSqlDataset::new().build(driver_name, data_source_name, query, scope)`.
pub fn experimental_sql_dataset<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    driver_name: O0,
    data_source_name: O1,
    query: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ExperimentalSqlDataset::new().build(driver_name, data_source_name, query, scope)
}

/// Builder for the `ExperimentalStatsAggregatorHandle` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ExperimentalStatsAggregatorHandle {
    container: ::std::option::Option<::std::string::String>,
    shared_name: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ExperimentalStatsAggregatorHandle' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ExperimentalStatsAggregatorHandleInst {
    /// An instance of a fully built ExperimentalStatsAggregatorHandle Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ExperimentalStatsAggregatorHandle {
    /// Creates a new `ExperimentalStatsAggregatorHandle`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `container` attribute.
    pub fn container<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.container = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shared_name` attribute.
    pub fn shared_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.shared_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ExperimentalStatsAggregatorHandle` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("ExperimentalStatsAggregatorHandle", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.container {
                nd.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                nd.set_attr_string("shared_name", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ExperimentalStatsAggregatorHandle' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        scope: &mut crate::Scope,
    ) -> crate::Result<ExperimentalStatsAggregatorHandleInst> {
        let op = scope.new_operation("ExperimentalStatsAggregatorHandle", |builder| {
            if let ::std::option::Option::Some(value) = &self.container {
                builder.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                builder.set_attr_string("shared_name", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ExperimentalStatsAggregatorHandleInst { op })
    }
}
impl ExperimentalStatsAggregatorHandleInst {
    /// Returns the 'handle' Output of this 'ExperimentalStatsAggregatorHandle' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
}
impl From<ExperimentalStatsAggregatorHandleInst> for crate::Operation {
    fn from(inst: ExperimentalStatsAggregatorHandleInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ExperimentalStatsAggregatorHandle::new().build(scope)`.
pub fn experimental_stats_aggregator_handle(
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ExperimentalStatsAggregatorHandle::new().build(scope)
}

/// Builder for the `ExperimentalStatsAggregatorSummary` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ExperimentalStatsAggregatorSummary {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ExperimentalStatsAggregatorSummary' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ExperimentalStatsAggregatorSummaryInst {
    /// An instance of a fully built ExperimentalStatsAggregatorSummary Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ExperimentalStatsAggregatorSummary {
    /// Creates a new `ExperimentalStatsAggregatorSummary`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ExperimentalStatsAggregatorSummary` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        iterator: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(iterator.into(), scope)
    }
    fn build_impl(
        &self,
        iterator: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ExperimentalStatsAggregatorSummary", |nd| {
            nd.add_input(iterator);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ExperimentalStatsAggregatorSummary' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        iterator: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ExperimentalStatsAggregatorSummaryInst> {
        let op = scope.new_operation("ExperimentalStatsAggregatorSummary", |builder| {
            builder.add_input(iterator);
            ::std::result::Result::Ok(())
        })?;
        Ok(ExperimentalStatsAggregatorSummaryInst { op })
    }
}
impl ExperimentalStatsAggregatorSummaryInst {
    /// Returns the 'summary' Output of this 'ExperimentalStatsAggregatorSummary' operation.
    pub fn summary(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'iterator' Input of this 'ExperimentalStatsAggregatorSummary' operation.
    pub fn iterator(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<ExperimentalStatsAggregatorSummaryInst> for crate::Operation {
    fn from(inst: ExperimentalStatsAggregatorSummaryInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ExperimentalStatsAggregatorSummary::new().build(iterator, scope)`.
pub fn experimental_stats_aggregator_summary<O0: ::std::convert::Into<crate::Output>>(
    iterator: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ExperimentalStatsAggregatorSummary::new().build(iterator, scope)
}

/// Builder for the `ExperimentalTakeWhileDataset` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ExperimentalTakeWhileDataset {
    predicate: ::std::option::Option<::std::string::String>,
    Targuments: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ExperimentalTakeWhileDataset' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ExperimentalTakeWhileDatasetInst {
    /// An instance of a fully built ExperimentalTakeWhileDataset Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ExperimentalTakeWhileDataset {
    /// Creates a new `ExperimentalTakeWhileDataset`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `predicate` attribute.
    pub fn predicate<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.predicate = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Targuments` attribute.
    pub fn Targuments<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Targuments = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ExperimentalTakeWhileDataset` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input_dataset: O0,
        other_arguments: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input_dataset.into(), other_arguments.into(), scope)
    }
    fn build_impl(
        &self,
        input_dataset: crate::Output,
        other_arguments: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ExperimentalTakeWhileDataset", |nd| {
            nd.add_input(input_dataset);
            nd.add_input(other_arguments);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.predicate {
                nd.set_attr_string("predicate", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Targuments {
                nd.set_attr_type_list("Targuments", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ExperimentalTakeWhileDataset' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_dataset: crate::Output,
        other_arguments: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ExperimentalTakeWhileDatasetInst> {
        let op = scope.new_operation("ExperimentalTakeWhileDataset", |builder| {
            builder.add_input(input_dataset);
            builder.add_input(other_arguments);
            if let ::std::option::Option::Some(value) = &self.predicate {
                builder.set_attr_string("predicate", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Targuments {
                builder.set_attr_type_list("Targuments", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ExperimentalTakeWhileDatasetInst { op })
    }
}
impl ExperimentalTakeWhileDatasetInst {
    /// Returns the 'handle' Output of this 'ExperimentalTakeWhileDataset' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_dataset' Input of this 'ExperimentalTakeWhileDataset' operation.
    pub fn input_dataset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'other_arguments' Input of this 'ExperimentalTakeWhileDataset' operation.
    pub fn other_arguments(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<ExperimentalTakeWhileDatasetInst> for crate::Operation {
    fn from(inst: ExperimentalTakeWhileDatasetInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ExperimentalTakeWhileDataset::new().build(input_dataset, other_arguments, scope)`.
pub fn experimental_take_while_dataset<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    input_dataset: O0,
    other_arguments: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ExperimentalTakeWhileDataset::new().build(input_dataset, other_arguments, scope)
}

/// Builder for the `ExperimentalThreadPoolDataset` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ExperimentalThreadPoolDataset {
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ExperimentalThreadPoolDataset' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ExperimentalThreadPoolDatasetInst {
    /// An instance of a fully built ExperimentalThreadPoolDataset Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ExperimentalThreadPoolDataset {
    /// Creates a new `ExperimentalThreadPoolDataset`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ExperimentalThreadPoolDataset` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input_dataset: O0,
        thread_pool: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input_dataset.into(), thread_pool.into(), scope)
    }
    fn build_impl(
        &self,
        input_dataset: crate::Output,
        thread_pool: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ExperimentalThreadPoolDataset", |nd| {
            nd.add_input(input_dataset);
            nd.add_input(thread_pool);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ExperimentalThreadPoolDataset' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_dataset: crate::Output,
        thread_pool: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ExperimentalThreadPoolDatasetInst> {
        let op = scope.new_operation("ExperimentalThreadPoolDataset", |builder| {
            builder.add_input(input_dataset);
            builder.add_input(thread_pool);
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ExperimentalThreadPoolDatasetInst { op })
    }
}
impl ExperimentalThreadPoolDatasetInst {
    /// Returns the 'handle' Output of this 'ExperimentalThreadPoolDataset' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_dataset' Input of this 'ExperimentalThreadPoolDataset' operation.
    pub fn input_dataset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'thread_pool' Input of this 'ExperimentalThreadPoolDataset' operation.
    pub fn thread_pool(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<ExperimentalThreadPoolDatasetInst> for crate::Operation {
    fn from(inst: ExperimentalThreadPoolDatasetInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ExperimentalThreadPoolDataset::new().build(input_dataset, thread_pool, scope)`.
pub fn experimental_thread_pool_dataset<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    input_dataset: O0,
    thread_pool: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ExperimentalThreadPoolDataset::new().build(input_dataset, thread_pool, scope)
}

/// Builder for the `ExperimentalThreadPoolHandle` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ExperimentalThreadPoolHandle {
    num_threads: ::std::option::Option<i64>,
    max_intra_op_parallelism: ::std::option::Option<i64>,
    display_name: ::std::option::Option<::std::string::String>,
    container: ::std::option::Option<::std::string::String>,
    shared_name: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ExperimentalThreadPoolHandle' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ExperimentalThreadPoolHandleInst {
    /// An instance of a fully built ExperimentalThreadPoolHandle Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ExperimentalThreadPoolHandle {
    /// Creates a new `ExperimentalThreadPoolHandle`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `num_threads` attribute.
    pub fn num_threads<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.num_threads = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `max_intra_op_parallelism` attribute.
    pub fn max_intra_op_parallelism<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.max_intra_op_parallelism = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `display_name` attribute.
    pub fn display_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.display_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `container` attribute.
    pub fn container<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.container = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shared_name` attribute.
    pub fn shared_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.shared_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ExperimentalThreadPoolHandle` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("ExperimentalThreadPoolHandle", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.num_threads {
                nd.set_attr_int("num_threads", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.max_intra_op_parallelism {
                nd.set_attr_int("max_intra_op_parallelism", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.display_name {
                nd.set_attr_string("display_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.container {
                nd.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                nd.set_attr_string("shared_name", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ExperimentalThreadPoolHandle' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        scope: &mut crate::Scope,
    ) -> crate::Result<ExperimentalThreadPoolHandleInst> {
        let op = scope.new_operation("ExperimentalThreadPoolHandle", |builder| {
            if let ::std::option::Option::Some(value) = &self.num_threads {
                builder.set_attr_int("num_threads", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.max_intra_op_parallelism {
                builder.set_attr_int("max_intra_op_parallelism", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.display_name {
                builder.set_attr_string("display_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.container {
                builder.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                builder.set_attr_string("shared_name", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ExperimentalThreadPoolHandleInst { op })
    }
}
impl ExperimentalThreadPoolHandleInst {
    /// Returns the 'handle' Output of this 'ExperimentalThreadPoolHandle' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
}
impl From<ExperimentalThreadPoolHandleInst> for crate::Operation {
    fn from(inst: ExperimentalThreadPoolHandleInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ExperimentalThreadPoolHandle::new().build(scope)`.
pub fn experimental_thread_pool_handle(
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ExperimentalThreadPoolHandle::new().build(scope)
}

/// Builder for the `ExperimentalUnbatchDataset` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ExperimentalUnbatchDataset {
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ExperimentalUnbatchDataset' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ExperimentalUnbatchDatasetInst {
    /// An instance of a fully built ExperimentalUnbatchDataset Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ExperimentalUnbatchDataset {
    /// Creates a new `ExperimentalUnbatchDataset`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ExperimentalUnbatchDataset` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input_dataset: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input_dataset.into(), scope)
    }
    fn build_impl(
        &self,
        input_dataset: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ExperimentalUnbatchDataset", |nd| {
            nd.add_input(input_dataset);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ExperimentalUnbatchDataset' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_dataset: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ExperimentalUnbatchDatasetInst> {
        let op = scope.new_operation("ExperimentalUnbatchDataset", |builder| {
            builder.add_input(input_dataset);
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ExperimentalUnbatchDatasetInst { op })
    }
}
impl ExperimentalUnbatchDatasetInst {
    /// Returns the 'handle' Output of this 'ExperimentalUnbatchDataset' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_dataset' Input of this 'ExperimentalUnbatchDataset' operation.
    pub fn input_dataset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<ExperimentalUnbatchDatasetInst> for crate::Operation {
    fn from(inst: ExperimentalUnbatchDatasetInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ExperimentalUnbatchDataset::new().build(input_dataset, scope)`.
pub fn experimental_unbatch_dataset<O0: ::std::convert::Into<crate::Output>>(
    input_dataset: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ExperimentalUnbatchDataset::new().build(input_dataset, scope)
}

/// Builder for the `ExperimentalUniqueDataset` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ExperimentalUniqueDataset {
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ExperimentalUniqueDataset' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ExperimentalUniqueDatasetInst {
    /// An instance of a fully built ExperimentalUniqueDataset Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ExperimentalUniqueDataset {
    /// Creates a new `ExperimentalUniqueDataset`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ExperimentalUniqueDataset` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input_dataset: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input_dataset.into(), scope)
    }
    fn build_impl(
        &self,
        input_dataset: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ExperimentalUniqueDataset", |nd| {
            nd.add_input(input_dataset);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ExperimentalUniqueDataset' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_dataset: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ExperimentalUniqueDatasetInst> {
        let op = scope.new_operation("ExperimentalUniqueDataset", |builder| {
            builder.add_input(input_dataset);
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ExperimentalUniqueDatasetInst { op })
    }
}
impl ExperimentalUniqueDatasetInst {
    /// Returns the 'handle' Output of this 'ExperimentalUniqueDataset' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_dataset' Input of this 'ExperimentalUniqueDataset' operation.
    pub fn input_dataset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<ExperimentalUniqueDatasetInst> for crate::Operation {
    fn from(inst: ExperimentalUniqueDatasetInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ExperimentalUniqueDataset::new().build(input_dataset, scope)`.
pub fn experimental_unique_dataset<O0: ::std::convert::Into<crate::Output>>(
    input_dataset: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ExperimentalUniqueDataset::new().build(input_dataset, scope)
}

/// Builder for the `Expint` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Expint {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Expint' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ExpintInst {
    /// An instance of a fully built Expint Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Expint {
    /// Creates a new `Expint`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Expint` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        x: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Expint", |nd| {
            nd.add_input(x);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Expint' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ExpintInst> {
        let op = scope.new_operation("Expint", |builder| {
            builder.add_input(x);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ExpintInst { op })
    }
}
impl ExpintInst {
    /// Returns the 'y' Output of this 'Expint' operation.
    pub fn y(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'Expint' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<ExpintInst> for crate::Operation {
    fn from(inst: ExpintInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Expint::new().build(x, scope)`.
pub fn expint<O0: ::std::convert::Into<crate::Output>>(
    x: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Expint::new().build(x, scope)
}

/// Builder for the `Expm1` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Expm1 {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Expm1' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct Expm1Inst {
    /// An instance of a fully built Expm1 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Expm1 {
    /// Creates a new `Expm1`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Expm1` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        x: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Expm1", |nd| {
            nd.add_input(x);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Expm1' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<Expm1Inst> {
        let op = scope.new_operation("Expm1", |builder| {
            builder.add_input(x);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(Expm1Inst { op })
    }
}
impl Expm1Inst {
    /// Returns the 'y' Output of this 'Expm1' operation.
    pub fn y(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'Expm1' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<Expm1Inst> for crate::Operation {
    fn from(inst: Expm1Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Expm1::new().build(x, scope)`.
pub fn expm1<O0: ::std::convert::Into<crate::Output>>(
    x: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Expm1::new().build(x, scope)
}

/// Builder for the `ExtractGlimpse` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ExtractGlimpse {
    centered: ::std::option::Option<bool>,
    normalized: ::std::option::Option<bool>,
    uniform_noise: ::std::option::Option<bool>,
    noise: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ExtractGlimpse' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ExtractGlimpseInst {
    /// An instance of a fully built ExtractGlimpse Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ExtractGlimpse {
    /// Creates a new `ExtractGlimpse`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `centered` attribute.
    pub fn centered<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.centered = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `normalized` attribute.
    pub fn normalized<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.normalized = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `uniform_noise` attribute.
    pub fn uniform_noise<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.uniform_noise = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `noise` attribute.
    pub fn noise<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.noise = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ExtractGlimpse` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        size: O1,
        offsets: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), size.into(), offsets.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        size: crate::Output,
        offsets: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ExtractGlimpse", |nd| {
            nd.add_input(input);
            nd.add_input(size);
            nd.add_input(offsets);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.centered {
                nd.set_attr_bool("centered", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.normalized {
                nd.set_attr_bool("normalized", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.uniform_noise {
                nd.set_attr_bool("uniform_noise", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.noise {
                nd.set_attr_string("noise", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ExtractGlimpse' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        size: crate::Output,
        offsets: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ExtractGlimpseInst> {
        let op = scope.new_operation("ExtractGlimpse", |builder| {
            builder.add_input(input);
            builder.add_input(size);
            builder.add_input(offsets);
            if let ::std::option::Option::Some(value) = &self.centered {
                builder.set_attr_bool("centered", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.normalized {
                builder.set_attr_bool("normalized", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.uniform_noise {
                builder.set_attr_bool("uniform_noise", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.noise {
                builder.set_attr_string("noise", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ExtractGlimpseInst { op })
    }
}
impl ExtractGlimpseInst {
    /// Returns the 'glimpse' Output of this 'ExtractGlimpse' operation.
    pub fn glimpse(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'ExtractGlimpse' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'size' Input of this 'ExtractGlimpse' operation.
    pub fn size(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'offsets' Input of this 'ExtractGlimpse' operation.
    pub fn offsets(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<ExtractGlimpseInst> for crate::Operation {
    fn from(inst: ExtractGlimpseInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ExtractGlimpse::new().build(input, size, offsets, scope)`.
pub fn extract_glimpse<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    input: O0,
    size: O1,
    offsets: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ExtractGlimpse::new().build(input, size, offsets, scope)
}

/// Builder for the `ExtractGlimpseV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ExtractGlimpseV2 {
    centered: ::std::option::Option<bool>,
    normalized: ::std::option::Option<bool>,
    uniform_noise: ::std::option::Option<bool>,
    noise: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ExtractGlimpseV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ExtractGlimpseV2Inst {
    /// An instance of a fully built ExtractGlimpseV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ExtractGlimpseV2 {
    /// Creates a new `ExtractGlimpseV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `centered` attribute.
    pub fn centered<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.centered = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `normalized` attribute.
    pub fn normalized<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.normalized = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `uniform_noise` attribute.
    pub fn uniform_noise<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.uniform_noise = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `noise` attribute.
    pub fn noise<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.noise = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ExtractGlimpseV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        size: O1,
        offsets: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), size.into(), offsets.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        size: crate::Output,
        offsets: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ExtractGlimpseV2", |nd| {
            nd.add_input(input);
            nd.add_input(size);
            nd.add_input(offsets);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.centered {
                nd.set_attr_bool("centered", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.normalized {
                nd.set_attr_bool("normalized", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.uniform_noise {
                nd.set_attr_bool("uniform_noise", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.noise {
                nd.set_attr_string("noise", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ExtractGlimpseV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        size: crate::Output,
        offsets: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ExtractGlimpseV2Inst> {
        let op = scope.new_operation("ExtractGlimpseV2", |builder| {
            builder.add_input(input);
            builder.add_input(size);
            builder.add_input(offsets);
            if let ::std::option::Option::Some(value) = &self.centered {
                builder.set_attr_bool("centered", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.normalized {
                builder.set_attr_bool("normalized", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.uniform_noise {
                builder.set_attr_bool("uniform_noise", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.noise {
                builder.set_attr_string("noise", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ExtractGlimpseV2Inst { op })
    }
}
impl ExtractGlimpseV2Inst {
    /// Returns the 'glimpse' Output of this 'ExtractGlimpseV2' operation.
    pub fn glimpse(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'ExtractGlimpseV2' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'size' Input of this 'ExtractGlimpseV2' operation.
    pub fn size(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'offsets' Input of this 'ExtractGlimpseV2' operation.
    pub fn offsets(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<ExtractGlimpseV2Inst> for crate::Operation {
    fn from(inst: ExtractGlimpseV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ExtractGlimpseV2::new().build(input, size, offsets, scope)`.
pub fn extract_glimpse_v2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    input: O0,
    size: O1,
    offsets: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ExtractGlimpseV2::new().build(input, size, offsets, scope)
}

/// Builder for the `ExtractImagePatches` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ExtractImagePatches {
    ksizes: ::std::option::Option<::std::vec::Vec<i64>>,
    strides: ::std::option::Option<::std::vec::Vec<i64>>,
    rates: ::std::option::Option<::std::vec::Vec<i64>>,
    T: ::std::option::Option<crate::DataType>,
    padding: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ExtractImagePatches' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ExtractImagePatchesInst {
    /// An instance of a fully built ExtractImagePatches Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ExtractImagePatches {
    /// Creates a new `ExtractImagePatches`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `ksizes` attribute.
    pub fn ksizes<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.ksizes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `strides` attribute.
    pub fn strides<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.strides = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `rates` attribute.
    pub fn rates<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.rates = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `padding` attribute.
    pub fn padding<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.padding = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ExtractImagePatches` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        images: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(images.into(), scope)
    }
    fn build_impl(
        &self,
        images: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ExtractImagePatches", |nd| {
            nd.add_input(images);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.ksizes {
                nd.set_attr_int_list("ksizes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.strides {
                nd.set_attr_int_list("strides", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.rates {
                nd.set_attr_int_list("rates", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding {
                nd.set_attr_string("padding", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ExtractImagePatches' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        images: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ExtractImagePatchesInst> {
        let op = scope.new_operation("ExtractImagePatches", |builder| {
            builder.add_input(images);
            if let ::std::option::Option::Some(value) = &self.ksizes {
                builder.set_attr_int_list("ksizes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.strides {
                builder.set_attr_int_list("strides", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.rates {
                builder.set_attr_int_list("rates", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding {
                builder.set_attr_string("padding", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ExtractImagePatchesInst { op })
    }
}
impl ExtractImagePatchesInst {
    /// Returns the 'patches' Output of this 'ExtractImagePatches' operation.
    pub fn patches(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'images' Input of this 'ExtractImagePatches' operation.
    pub fn images(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<ExtractImagePatchesInst> for crate::Operation {
    fn from(inst: ExtractImagePatchesInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ExtractImagePatches::new().build(images, scope)`.
pub fn extract_image_patches<O0: ::std::convert::Into<crate::Output>>(
    images: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ExtractImagePatches::new().build(images, scope)
}

/// Builder for the `ExtractJpegShape` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ExtractJpegShape {
    output_type: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ExtractJpegShape' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ExtractJpegShapeInst {
    /// An instance of a fully built ExtractJpegShape Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ExtractJpegShape {
    /// Creates a new `ExtractJpegShape`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `output_type` attribute.
    pub fn output_type<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_type = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ExtractJpegShape` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        contents: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(contents.into(), scope)
    }
    fn build_impl(
        &self,
        contents: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ExtractJpegShape", |nd| {
            nd.add_input(contents);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.output_type {
                nd.set_attr_type("output_type", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ExtractJpegShape' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        contents: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ExtractJpegShapeInst> {
        let op = scope.new_operation("ExtractJpegShape", |builder| {
            builder.add_input(contents);
            if let ::std::option::Option::Some(value) = &self.output_type {
                builder.set_attr_type("output_type", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ExtractJpegShapeInst { op })
    }
}
impl ExtractJpegShapeInst {
    /// Returns the 'image_shape' Output of this 'ExtractJpegShape' operation.
    pub fn image_shape(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'contents' Input of this 'ExtractJpegShape' operation.
    pub fn contents(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<ExtractJpegShapeInst> for crate::Operation {
    fn from(inst: ExtractJpegShapeInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ExtractJpegShape::new().build(contents, scope)`.
pub fn extract_jpeg_shape<O0: ::std::convert::Into<crate::Output>>(
    contents: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ExtractJpegShape::new().build(contents, scope)
}

/// Builder for the `ExtractVolumePatches` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ExtractVolumePatches {
    ksizes: ::std::option::Option<::std::vec::Vec<i64>>,
    strides: ::std::option::Option<::std::vec::Vec<i64>>,
    T: ::std::option::Option<crate::DataType>,
    padding: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ExtractVolumePatches' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ExtractVolumePatchesInst {
    /// An instance of a fully built ExtractVolumePatches Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ExtractVolumePatches {
    /// Creates a new `ExtractVolumePatches`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `ksizes` attribute.
    pub fn ksizes<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.ksizes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `strides` attribute.
    pub fn strides<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.strides = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `padding` attribute.
    pub fn padding<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.padding = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ExtractVolumePatches` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ExtractVolumePatches", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.ksizes {
                nd.set_attr_int_list("ksizes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.strides {
                nd.set_attr_int_list("strides", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding {
                nd.set_attr_string("padding", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ExtractVolumePatches' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ExtractVolumePatchesInst> {
        let op = scope.new_operation("ExtractVolumePatches", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.ksizes {
                builder.set_attr_int_list("ksizes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.strides {
                builder.set_attr_int_list("strides", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding {
                builder.set_attr_string("padding", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ExtractVolumePatchesInst { op })
    }
}
impl ExtractVolumePatchesInst {
    /// Returns the 'patches' Output of this 'ExtractVolumePatches' operation.
    pub fn patches(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'ExtractVolumePatches' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<ExtractVolumePatchesInst> for crate::Operation {
    fn from(inst: ExtractVolumePatchesInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ExtractVolumePatches::new().build(input, scope)`.
pub fn extract_volume_patches<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ExtractVolumePatches::new().build(input, scope)
}

/// Builder for the `FFT` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct FFT {
    Tcomplex: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'FFT' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct FFTInst {
    /// An instance of a fully built FFT Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl FFT {
    /// Creates a new `FFT`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `Tcomplex` attribute.
    pub fn Tcomplex<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tcomplex = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `FFT` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("FFT", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.Tcomplex {
                nd.set_attr_type("Tcomplex", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'FFT' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<FFTInst> {
        let op = scope.new_operation("FFT", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.Tcomplex {
                builder.set_attr_type("Tcomplex", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(FFTInst { op })
    }
}
impl FFTInst {
    /// Returns the 'output' Output of this 'FFT' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'FFT' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<FFTInst> for crate::Operation {
    fn from(inst: FFTInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `FFT::new().build(input, scope)`.
pub fn fft<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    FFT::new().build(input, scope)
}

/// Builder for the `FFT2D` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct FFT2D {
    Tcomplex: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'FFT2D' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct FFT2DInst {
    /// An instance of a fully built FFT2D Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl FFT2D {
    /// Creates a new `FFT2D`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `Tcomplex` attribute.
    pub fn Tcomplex<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tcomplex = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `FFT2D` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("FFT2D", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.Tcomplex {
                nd.set_attr_type("Tcomplex", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'FFT2D' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<FFT2DInst> {
        let op = scope.new_operation("FFT2D", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.Tcomplex {
                builder.set_attr_type("Tcomplex", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(FFT2DInst { op })
    }
}
impl FFT2DInst {
    /// Returns the 'output' Output of this 'FFT2D' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'FFT2D' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<FFT2DInst> for crate::Operation {
    fn from(inst: FFT2DInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `FFT2D::new().build(input, scope)`.
pub fn fft2_d<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    FFT2D::new().build(input, scope)
}

/// Builder for the `FFT3D` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct FFT3D {
    Tcomplex: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'FFT3D' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct FFT3DInst {
    /// An instance of a fully built FFT3D Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl FFT3D {
    /// Creates a new `FFT3D`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `Tcomplex` attribute.
    pub fn Tcomplex<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tcomplex = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `FFT3D` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("FFT3D", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.Tcomplex {
                nd.set_attr_type("Tcomplex", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'FFT3D' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<FFT3DInst> {
        let op = scope.new_operation("FFT3D", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.Tcomplex {
                builder.set_attr_type("Tcomplex", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(FFT3DInst { op })
    }
}
impl FFT3DInst {
    /// Returns the 'output' Output of this 'FFT3D' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'FFT3D' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<FFT3DInst> for crate::Operation {
    fn from(inst: FFT3DInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `FFT3D::new().build(input, scope)`.
pub fn fft3_d<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    FFT3D::new().build(input, scope)
}

/// Builder for the `FIFOQueue` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct FIFOQueue {
    component_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    capacity: ::std::option::Option<i64>,
    container: ::std::option::Option<::std::string::String>,
    shared_name: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'FIFOQueue' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct FIFOQueueInst {
    /// An instance of a fully built FIFOQueue Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl FIFOQueue {
    /// Creates a new `FIFOQueue`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `component_types` attribute.
    pub fn component_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.component_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shapes` attribute.
    pub fn shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `capacity` attribute.
    pub fn capacity<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.capacity = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `container` attribute.
    pub fn container<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.container = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shared_name` attribute.
    pub fn shared_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.shared_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `FIFOQueue` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("FIFOQueue", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.component_types {
                nd.set_attr_type_list("component_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shapes {
                nd.set_attr_shape_list("shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.capacity {
                nd.set_attr_int("capacity", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.container {
                nd.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                nd.set_attr_string("shared_name", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'FIFOQueue' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(&self, scope: &mut crate::Scope) -> crate::Result<FIFOQueueInst> {
        let op = scope.new_operation("FIFOQueue", |builder| {
            if let ::std::option::Option::Some(value) = &self.component_types {
                builder.set_attr_type_list("component_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shapes {
                builder.set_attr_shape_list("shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.capacity {
                builder.set_attr_int("capacity", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.container {
                builder.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                builder.set_attr_string("shared_name", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(FIFOQueueInst { op })
    }
}
impl FIFOQueueInst {
    /// Returns the 'handle' Output of this 'FIFOQueue' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
}
impl From<FIFOQueueInst> for crate::Operation {
    fn from(inst: FIFOQueueInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `FIFOQueue::new().build(scope)`.
pub fn fifoqueue(scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
    FIFOQueue::new().build(scope)
}

/// Builder for the `FIFOQueueV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct FIFOQueueV2 {
    component_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    capacity: ::std::option::Option<i64>,
    container: ::std::option::Option<::std::string::String>,
    shared_name: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'FIFOQueueV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct FIFOQueueV2Inst {
    /// An instance of a fully built FIFOQueueV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl FIFOQueueV2 {
    /// Creates a new `FIFOQueueV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `component_types` attribute.
    pub fn component_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.component_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shapes` attribute.
    pub fn shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `capacity` attribute.
    pub fn capacity<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.capacity = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `container` attribute.
    pub fn container<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.container = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shared_name` attribute.
    pub fn shared_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.shared_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `FIFOQueueV2` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("FIFOQueueV2", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.component_types {
                nd.set_attr_type_list("component_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shapes {
                nd.set_attr_shape_list("shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.capacity {
                nd.set_attr_int("capacity", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.container {
                nd.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                nd.set_attr_string("shared_name", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'FIFOQueueV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(&self, scope: &mut crate::Scope) -> crate::Result<FIFOQueueV2Inst> {
        let op = scope.new_operation("FIFOQueueV2", |builder| {
            if let ::std::option::Option::Some(value) = &self.component_types {
                builder.set_attr_type_list("component_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shapes {
                builder.set_attr_shape_list("shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.capacity {
                builder.set_attr_int("capacity", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.container {
                builder.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                builder.set_attr_string("shared_name", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(FIFOQueueV2Inst { op })
    }
}
impl FIFOQueueV2Inst {
    /// Returns the 'handle' Output of this 'FIFOQueueV2' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
}
impl From<FIFOQueueV2Inst> for crate::Operation {
    fn from(inst: FIFOQueueV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `FIFOQueueV2::new().build(scope)`.
pub fn fifoqueue_v2(scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
    FIFOQueueV2::new().build(scope)
}

/// Builder for the `Fact` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Fact {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Fact' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct FactInst {
    /// An instance of a fully built Fact Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Fact {
    /// Creates a new `Fact`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Fact` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("Fact", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Fact' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(&self, scope: &mut crate::Scope) -> crate::Result<FactInst> {
        let op = scope.new_operation("Fact", |builder| ::std::result::Result::Ok(()))?;
        Ok(FactInst { op })
    }
}
impl FactInst {
    /// Returns the 'fact' Output of this 'Fact' operation.
    pub fn fact(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
}
impl From<FactInst> for crate::Operation {
    fn from(inst: FactInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Fact::new().build(scope)`.
pub fn fact(scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
    Fact::new().build(scope)
}

/// Builder for the `FakeParam` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct FakeParam {
    dtype: ::std::option::Option<crate::DataType>,
    shape: ::std::option::Option<crate::Shape>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'FakeParam' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct FakeParamInst {
    /// An instance of a fully built FakeParam Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl FakeParam {
    /// Creates a new `FakeParam`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `dtype` attribute.
    pub fn dtype<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shape` attribute.
    pub fn shape<ArgType: ::std::convert::Into<crate::Shape>>(mut self, value: ArgType) -> Self {
        self.shape = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `FakeParam` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("FakeParam", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                nd.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shape {
                nd.set_attr_shape("shape", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'FakeParam' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(&self, scope: &mut crate::Scope) -> crate::Result<FakeParamInst> {
        let op = scope.new_operation("FakeParam", |builder| {
            if let ::std::option::Option::Some(value) = &self.dtype {
                builder.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shape {
                builder.set_attr_shape("shape", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(FakeParamInst { op })
    }
}
impl FakeParamInst {
    /// Returns the 'output' Output of this 'FakeParam' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
}
impl From<FakeParamInst> for crate::Operation {
    fn from(inst: FakeParamInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `FakeParam::new().build(scope)`.
pub fn fake_param(scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
    FakeParam::new().build(scope)
}

/// Builder for the `FakeQuantWithMinMaxArgs` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct FakeQuantWithMinMaxArgs {
    min: ::std::option::Option<f32>,
    max: ::std::option::Option<f32>,
    num_bits: ::std::option::Option<i64>,
    narrow_range: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'FakeQuantWithMinMaxArgs' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct FakeQuantWithMinMaxArgsInst {
    /// An instance of a fully built FakeQuantWithMinMaxArgs Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl FakeQuantWithMinMaxArgs {
    /// Creates a new `FakeQuantWithMinMaxArgs`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `min` attribute.
    pub fn min<ArgType: ::std::convert::Into<f32>>(mut self, value: ArgType) -> Self {
        self.min = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `max` attribute.
    pub fn max<ArgType: ::std::convert::Into<f32>>(mut self, value: ArgType) -> Self {
        self.max = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `num_bits` attribute.
    pub fn num_bits<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.num_bits = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `narrow_range` attribute.
    pub fn narrow_range<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.narrow_range = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `FakeQuantWithMinMaxArgs` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        inputs: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(inputs.into(), scope)
    }
    fn build_impl(
        &self,
        inputs: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("FakeQuantWithMinMaxArgs", |nd| {
            nd.add_input(inputs);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.min {
                nd.set_attr_float("min", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.max {
                nd.set_attr_float("max", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_bits {
                nd.set_attr_int("num_bits", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.narrow_range {
                nd.set_attr_bool("narrow_range", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'FakeQuantWithMinMaxArgs' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        inputs: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<FakeQuantWithMinMaxArgsInst> {
        let op = scope.new_operation("FakeQuantWithMinMaxArgs", |builder| {
            builder.add_input(inputs);
            if let ::std::option::Option::Some(value) = &self.min {
                builder.set_attr_float("min", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.max {
                builder.set_attr_float("max", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_bits {
                builder.set_attr_int("num_bits", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.narrow_range {
                builder.set_attr_bool("narrow_range", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(FakeQuantWithMinMaxArgsInst { op })
    }
}
impl FakeQuantWithMinMaxArgsInst {
    /// Returns the 'outputs' Output of this 'FakeQuantWithMinMaxArgs' operation.
    pub fn outputs(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'inputs' Input of this 'FakeQuantWithMinMaxArgs' operation.
    pub fn inputs(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<FakeQuantWithMinMaxArgsInst> for crate::Operation {
    fn from(inst: FakeQuantWithMinMaxArgsInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `FakeQuantWithMinMaxArgs::new().build(inputs, scope)`.
pub fn fake_quant_with_min_max_args<O0: ::std::convert::Into<crate::Output>>(
    inputs: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    FakeQuantWithMinMaxArgs::new().build(inputs, scope)
}

/// Builder for the `FakeQuantWithMinMaxArgsGradient` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct FakeQuantWithMinMaxArgsGradient {
    min: ::std::option::Option<f32>,
    max: ::std::option::Option<f32>,
    num_bits: ::std::option::Option<i64>,
    narrow_range: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'FakeQuantWithMinMaxArgsGradient' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct FakeQuantWithMinMaxArgsGradientInst {
    /// An instance of a fully built FakeQuantWithMinMaxArgsGradient Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl FakeQuantWithMinMaxArgsGradient {
    /// Creates a new `FakeQuantWithMinMaxArgsGradient`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `min` attribute.
    pub fn min<ArgType: ::std::convert::Into<f32>>(mut self, value: ArgType) -> Self {
        self.min = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `max` attribute.
    pub fn max<ArgType: ::std::convert::Into<f32>>(mut self, value: ArgType) -> Self {
        self.max = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `num_bits` attribute.
    pub fn num_bits<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.num_bits = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `narrow_range` attribute.
    pub fn narrow_range<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.narrow_range = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `FakeQuantWithMinMaxArgsGradient` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        gradients: O0,
        inputs: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(gradients.into(), inputs.into(), scope)
    }
    fn build_impl(
        &self,
        gradients: crate::Output,
        inputs: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("FakeQuantWithMinMaxArgsGradient", |nd| {
            nd.add_input(gradients);
            nd.add_input(inputs);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.min {
                nd.set_attr_float("min", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.max {
                nd.set_attr_float("max", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_bits {
                nd.set_attr_int("num_bits", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.narrow_range {
                nd.set_attr_bool("narrow_range", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'FakeQuantWithMinMaxArgsGradient' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        gradients: crate::Output,
        inputs: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<FakeQuantWithMinMaxArgsGradientInst> {
        let op = scope.new_operation("FakeQuantWithMinMaxArgsGradient", |builder| {
            builder.add_input(gradients);
            builder.add_input(inputs);
            if let ::std::option::Option::Some(value) = &self.min {
                builder.set_attr_float("min", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.max {
                builder.set_attr_float("max", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_bits {
                builder.set_attr_int("num_bits", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.narrow_range {
                builder.set_attr_bool("narrow_range", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(FakeQuantWithMinMaxArgsGradientInst { op })
    }
}
impl FakeQuantWithMinMaxArgsGradientInst {
    /// Returns the 'backprops' Output of this 'FakeQuantWithMinMaxArgsGradient' operation.
    pub fn backprops(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'gradients' Input of this 'FakeQuantWithMinMaxArgsGradient' operation.
    pub fn gradients(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'inputs' Input of this 'FakeQuantWithMinMaxArgsGradient' operation.
    pub fn inputs(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<FakeQuantWithMinMaxArgsGradientInst> for crate::Operation {
    fn from(inst: FakeQuantWithMinMaxArgsGradientInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `FakeQuantWithMinMaxArgsGradient::new().build(gradients, inputs, scope)`.
pub fn fake_quant_with_min_max_args_gradient<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    gradients: O0,
    inputs: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    FakeQuantWithMinMaxArgsGradient::new().build(gradients, inputs, scope)
}

/// Builder for the `FakeQuantWithMinMaxVars` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct FakeQuantWithMinMaxVars {
    num_bits: ::std::option::Option<i64>,
    narrow_range: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'FakeQuantWithMinMaxVars' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct FakeQuantWithMinMaxVarsInst {
    /// An instance of a fully built FakeQuantWithMinMaxVars Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl FakeQuantWithMinMaxVars {
    /// Creates a new `FakeQuantWithMinMaxVars`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `num_bits` attribute.
    pub fn num_bits<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.num_bits = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `narrow_range` attribute.
    pub fn narrow_range<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.narrow_range = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `FakeQuantWithMinMaxVars` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        inputs: O0,
        min: O1,
        max: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(inputs.into(), min.into(), max.into(), scope)
    }
    fn build_impl(
        &self,
        inputs: crate::Output,
        min: crate::Output,
        max: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("FakeQuantWithMinMaxVars", |nd| {
            nd.add_input(inputs);
            nd.add_input(min);
            nd.add_input(max);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.num_bits {
                nd.set_attr_int("num_bits", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.narrow_range {
                nd.set_attr_bool("narrow_range", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'FakeQuantWithMinMaxVars' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        inputs: crate::Output,
        min: crate::Output,
        max: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<FakeQuantWithMinMaxVarsInst> {
        let op = scope.new_operation("FakeQuantWithMinMaxVars", |builder| {
            builder.add_input(inputs);
            builder.add_input(min);
            builder.add_input(max);
            if let ::std::option::Option::Some(value) = &self.num_bits {
                builder.set_attr_int("num_bits", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.narrow_range {
                builder.set_attr_bool("narrow_range", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(FakeQuantWithMinMaxVarsInst { op })
    }
}
impl FakeQuantWithMinMaxVarsInst {
    /// Returns the 'outputs' Output of this 'FakeQuantWithMinMaxVars' operation.
    pub fn outputs(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'inputs' Input of this 'FakeQuantWithMinMaxVars' operation.
    pub fn inputs(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'min' Input of this 'FakeQuantWithMinMaxVars' operation.
    pub fn min(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'max' Input of this 'FakeQuantWithMinMaxVars' operation.
    pub fn max(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<FakeQuantWithMinMaxVarsInst> for crate::Operation {
    fn from(inst: FakeQuantWithMinMaxVarsInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `FakeQuantWithMinMaxVars::new().build(inputs, min, max, scope)`.
pub fn fake_quant_with_min_max_vars<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    inputs: O0,
    min: O1,
    max: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    FakeQuantWithMinMaxVars::new().build(inputs, min, max, scope)
}

/// Builder for the `FakeQuantWithMinMaxVarsGradient` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct FakeQuantWithMinMaxVarsGradient {
    num_bits: ::std::option::Option<i64>,
    narrow_range: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'FakeQuantWithMinMaxVarsGradient' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct FakeQuantWithMinMaxVarsGradientInst {
    /// An instance of a fully built FakeQuantWithMinMaxVarsGradient Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl FakeQuantWithMinMaxVarsGradient {
    /// Creates a new `FakeQuantWithMinMaxVarsGradient`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `num_bits` attribute.
    pub fn num_bits<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.num_bits = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `narrow_range` attribute.
    pub fn narrow_range<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.narrow_range = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `FakeQuantWithMinMaxVarsGradient` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
    >(
        &self,
        gradients: O0,
        inputs: O1,
        min: O2,
        max: O3,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            gradients.into(),
            inputs.into(),
            min.into(),
            max.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        gradients: crate::Output,
        inputs: crate::Output,
        min: crate::Output,
        max: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("FakeQuantWithMinMaxVarsGradient", |nd| {
            nd.add_input(gradients);
            nd.add_input(inputs);
            nd.add_input(min);
            nd.add_input(max);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.num_bits {
                nd.set_attr_int("num_bits", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.narrow_range {
                nd.set_attr_bool("narrow_range", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'FakeQuantWithMinMaxVarsGradient' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        gradients: crate::Output,
        inputs: crate::Output,
        min: crate::Output,
        max: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<FakeQuantWithMinMaxVarsGradientInst> {
        let op = scope.new_operation("FakeQuantWithMinMaxVarsGradient", |builder| {
            builder.add_input(gradients);
            builder.add_input(inputs);
            builder.add_input(min);
            builder.add_input(max);
            if let ::std::option::Option::Some(value) = &self.num_bits {
                builder.set_attr_int("num_bits", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.narrow_range {
                builder.set_attr_bool("narrow_range", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(FakeQuantWithMinMaxVarsGradientInst { op })
    }
}
impl FakeQuantWithMinMaxVarsGradientInst {
    /// Returns the 'backprops_wrt_input' Output of this 'FakeQuantWithMinMaxVarsGradient' operation.
    pub fn backprops_wrt_input(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'backprop_wrt_min' Output of this 'FakeQuantWithMinMaxVarsGradient' operation.
    pub fn backprop_wrt_min(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'backprop_wrt_max' Output of this 'FakeQuantWithMinMaxVarsGradient' operation.
    pub fn backprop_wrt_max(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns the 'gradients' Input of this 'FakeQuantWithMinMaxVarsGradient' operation.
    pub fn gradients(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'inputs' Input of this 'FakeQuantWithMinMaxVarsGradient' operation.
    pub fn inputs(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'min' Input of this 'FakeQuantWithMinMaxVarsGradient' operation.
    pub fn min(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'max' Input of this 'FakeQuantWithMinMaxVarsGradient' operation.
    pub fn max(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
}
impl From<FakeQuantWithMinMaxVarsGradientInst> for crate::Operation {
    fn from(inst: FakeQuantWithMinMaxVarsGradientInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `FakeQuantWithMinMaxVarsGradient::new().build(gradients, inputs, min, max, scope)`.
pub fn fake_quant_with_min_max_vars_gradient<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
>(
    gradients: O0,
    inputs: O1,
    min: O2,
    max: O3,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    FakeQuantWithMinMaxVarsGradient::new().build(gradients, inputs, min, max, scope)
}

/// Builder for the `FakeQuantWithMinMaxVarsPerChannel` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct FakeQuantWithMinMaxVarsPerChannel {
    num_bits: ::std::option::Option<i64>,
    narrow_range: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'FakeQuantWithMinMaxVarsPerChannel' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct FakeQuantWithMinMaxVarsPerChannelInst {
    /// An instance of a fully built FakeQuantWithMinMaxVarsPerChannel Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl FakeQuantWithMinMaxVarsPerChannel {
    /// Creates a new `FakeQuantWithMinMaxVarsPerChannel`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `num_bits` attribute.
    pub fn num_bits<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.num_bits = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `narrow_range` attribute.
    pub fn narrow_range<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.narrow_range = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `FakeQuantWithMinMaxVarsPerChannel` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        inputs: O0,
        min: O1,
        max: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(inputs.into(), min.into(), max.into(), scope)
    }
    fn build_impl(
        &self,
        inputs: crate::Output,
        min: crate::Output,
        max: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("FakeQuantWithMinMaxVarsPerChannel", |nd| {
            nd.add_input(inputs);
            nd.add_input(min);
            nd.add_input(max);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.num_bits {
                nd.set_attr_int("num_bits", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.narrow_range {
                nd.set_attr_bool("narrow_range", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'FakeQuantWithMinMaxVarsPerChannel' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        inputs: crate::Output,
        min: crate::Output,
        max: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<FakeQuantWithMinMaxVarsPerChannelInst> {
        let op = scope.new_operation("FakeQuantWithMinMaxVarsPerChannel", |builder| {
            builder.add_input(inputs);
            builder.add_input(min);
            builder.add_input(max);
            if let ::std::option::Option::Some(value) = &self.num_bits {
                builder.set_attr_int("num_bits", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.narrow_range {
                builder.set_attr_bool("narrow_range", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(FakeQuantWithMinMaxVarsPerChannelInst { op })
    }
}
impl FakeQuantWithMinMaxVarsPerChannelInst {
    /// Returns the 'outputs' Output of this 'FakeQuantWithMinMaxVarsPerChannel' operation.
    pub fn outputs(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'inputs' Input of this 'FakeQuantWithMinMaxVarsPerChannel' operation.
    pub fn inputs(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'min' Input of this 'FakeQuantWithMinMaxVarsPerChannel' operation.
    pub fn min(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'max' Input of this 'FakeQuantWithMinMaxVarsPerChannel' operation.
    pub fn max(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<FakeQuantWithMinMaxVarsPerChannelInst> for crate::Operation {
    fn from(inst: FakeQuantWithMinMaxVarsPerChannelInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `FakeQuantWithMinMaxVarsPerChannel::new().build(inputs, min, max, scope)`.
pub fn fake_quant_with_min_max_vars_per_channel<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    inputs: O0,
    min: O1,
    max: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    FakeQuantWithMinMaxVarsPerChannel::new().build(inputs, min, max, scope)
}

/// Builder for the `FakeQuantWithMinMaxVarsPerChannelGradient` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct FakeQuantWithMinMaxVarsPerChannelGradient {
    num_bits: ::std::option::Option<i64>,
    narrow_range: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'FakeQuantWithMinMaxVarsPerChannelGradient' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct FakeQuantWithMinMaxVarsPerChannelGradientInst {
    /// An instance of a fully built FakeQuantWithMinMaxVarsPerChannelGradient Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl FakeQuantWithMinMaxVarsPerChannelGradient {
    /// Creates a new `FakeQuantWithMinMaxVarsPerChannelGradient`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `num_bits` attribute.
    pub fn num_bits<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.num_bits = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `narrow_range` attribute.
    pub fn narrow_range<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.narrow_range = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `FakeQuantWithMinMaxVarsPerChannelGradient` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
    >(
        &self,
        gradients: O0,
        inputs: O1,
        min: O2,
        max: O3,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            gradients.into(),
            inputs.into(),
            min.into(),
            max.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        gradients: crate::Output,
        inputs: crate::Output,
        min: crate::Output,
        max: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("FakeQuantWithMinMaxVarsPerChannelGradient", |nd| {
            nd.add_input(gradients);
            nd.add_input(inputs);
            nd.add_input(min);
            nd.add_input(max);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.num_bits {
                nd.set_attr_int("num_bits", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.narrow_range {
                nd.set_attr_bool("narrow_range", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'FakeQuantWithMinMaxVarsPerChannelGradient' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        gradients: crate::Output,
        inputs: crate::Output,
        min: crate::Output,
        max: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<FakeQuantWithMinMaxVarsPerChannelGradientInst> {
        let op = scope.new_operation("FakeQuantWithMinMaxVarsPerChannelGradient", |builder| {
            builder.add_input(gradients);
            builder.add_input(inputs);
            builder.add_input(min);
            builder.add_input(max);
            if let ::std::option::Option::Some(value) = &self.num_bits {
                builder.set_attr_int("num_bits", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.narrow_range {
                builder.set_attr_bool("narrow_range", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(FakeQuantWithMinMaxVarsPerChannelGradientInst { op })
    }
}
impl FakeQuantWithMinMaxVarsPerChannelGradientInst {
    /// Returns the 'backprops_wrt_input' Output of this 'FakeQuantWithMinMaxVarsPerChannelGradient' operation.
    pub fn backprops_wrt_input(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'backprop_wrt_min' Output of this 'FakeQuantWithMinMaxVarsPerChannelGradient' operation.
    pub fn backprop_wrt_min(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'backprop_wrt_max' Output of this 'FakeQuantWithMinMaxVarsPerChannelGradient' operation.
    pub fn backprop_wrt_max(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns the 'gradients' Input of this 'FakeQuantWithMinMaxVarsPerChannelGradient' operation.
    pub fn gradients(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'inputs' Input of this 'FakeQuantWithMinMaxVarsPerChannelGradient' operation.
    pub fn inputs(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'min' Input of this 'FakeQuantWithMinMaxVarsPerChannelGradient' operation.
    pub fn min(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'max' Input of this 'FakeQuantWithMinMaxVarsPerChannelGradient' operation.
    pub fn max(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
}
impl From<FakeQuantWithMinMaxVarsPerChannelGradientInst> for crate::Operation {
    fn from(inst: FakeQuantWithMinMaxVarsPerChannelGradientInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `FakeQuantWithMinMaxVarsPerChannelGradient::new().build(gradients, inputs, min, max, scope)`.
pub fn fake_quant_with_min_max_vars_per_channel_gradient<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
>(
    gradients: O0,
    inputs: O1,
    min: O2,
    max: O3,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    FakeQuantWithMinMaxVarsPerChannelGradient::new().build(gradients, inputs, min, max, scope)
}

/// Builder for the `FakeQueue` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct FakeQueue {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'FakeQueue' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct FakeQueueInst {
    /// An instance of a fully built FakeQueue Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl FakeQueue {
    /// Creates a new `FakeQueue`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `FakeQueue` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        resource: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(resource.into(), scope)
    }
    fn build_impl(
        &self,
        resource: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("FakeQueue", |nd| {
            nd.add_input(resource);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'FakeQueue' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        resource: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<FakeQueueInst> {
        let op = scope.new_operation("FakeQueue", |builder| {
            builder.add_input(resource);
            ::std::result::Result::Ok(())
        })?;
        Ok(FakeQueueInst { op })
    }
}
impl FakeQueueInst {
    /// Returns the 'handle' Output of this 'FakeQueue' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'resource' Input of this 'FakeQueue' operation.
    pub fn resource(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<FakeQueueInst> for crate::Operation {
    fn from(inst: FakeQueueInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `FakeQueue::new().build(resource, scope)`.
pub fn fake_queue<O0: ::std::convert::Into<crate::Output>>(
    resource: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    FakeQueue::new().build(resource, scope)
}

/// Builder for the `FileSystemSetConfiguration` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct FileSystemSetConfiguration {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'FileSystemSetConfiguration' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct FileSystemSetConfigurationInst {
    /// An instance of a fully built FileSystemSetConfiguration Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl FileSystemSetConfiguration {
    /// Creates a new `FileSystemSetConfiguration`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `FileSystemSetConfiguration` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        scheme: O0,
        key: O1,
        value: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(scheme.into(), key.into(), value.into(), scope)
    }
    fn build_impl(
        &self,
        scheme: crate::Output,
        key: crate::Output,
        value: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("FileSystemSetConfiguration", |nd| {
            nd.add_input(scheme);
            nd.add_input(key);
            nd.add_input(value);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'FileSystemSetConfiguration' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        scheme: crate::Output,
        key: crate::Output,
        value: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<FileSystemSetConfigurationInst> {
        let op = scope.new_operation("FileSystemSetConfiguration", |builder| {
            builder.add_input(scheme);
            builder.add_input(key);
            builder.add_input(value);
            ::std::result::Result::Ok(())
        })?;
        Ok(FileSystemSetConfigurationInst { op })
    }
}
impl FileSystemSetConfigurationInst {
    /// Returns the 'scheme' Input of this 'FileSystemSetConfiguration' operation.
    pub fn scheme(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'key' Input of this 'FileSystemSetConfiguration' operation.
    pub fn key(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'value' Input of this 'FileSystemSetConfiguration' operation.
    pub fn value(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<FileSystemSetConfigurationInst> for crate::Operation {
    fn from(inst: FileSystemSetConfigurationInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `FileSystemSetConfiguration::new().build(scheme, key, value, scope)`.
pub fn file_system_set_configuration<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    scheme: O0,
    key: O1,
    value: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    FileSystemSetConfiguration::new().build(scheme, key, value, scope)
}

/// Builder for the `Fill` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Fill {
    T: ::std::option::Option<crate::DataType>,
    index_type: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Fill' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct FillInst {
    /// An instance of a fully built Fill Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Fill {
    /// Creates a new `Fill`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `index_type` attribute.
    pub fn index_type<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.index_type = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Fill` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        dims: O0,
        value: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(dims.into(), value.into(), scope)
    }
    fn build_impl(
        &self,
        dims: crate::Output,
        value: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Fill", |nd| {
            nd.add_input(dims);
            nd.add_input(value);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.index_type {
                nd.set_attr_type("index_type", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Fill' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        dims: crate::Output,
        value: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<FillInst> {
        let op = scope.new_operation("Fill", |builder| {
            builder.add_input(dims);
            builder.add_input(value);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.index_type {
                builder.set_attr_type("index_type", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(FillInst { op })
    }
}
impl FillInst {
    /// Returns the 'output' Output of this 'Fill' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'dims' Input of this 'Fill' operation.
    pub fn dims(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'value' Input of this 'Fill' operation.
    pub fn value(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<FillInst> for crate::Operation {
    fn from(inst: FillInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Fill::new().build(dims, value, scope)`.
pub fn fill<O0: ::std::convert::Into<crate::Output>, O1: ::std::convert::Into<crate::Output>>(
    dims: O0,
    value: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Fill::new().build(dims, value, scope)
}

/// Builder for the `FilterByLastComponentDataset` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct FilterByLastComponentDataset {
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'FilterByLastComponentDataset' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct FilterByLastComponentDatasetInst {
    /// An instance of a fully built FilterByLastComponentDataset Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl FilterByLastComponentDataset {
    /// Creates a new `FilterByLastComponentDataset`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `FilterByLastComponentDataset` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input_dataset: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input_dataset.into(), scope)
    }
    fn build_impl(
        &self,
        input_dataset: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("FilterByLastComponentDataset", |nd| {
            nd.add_input(input_dataset);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'FilterByLastComponentDataset' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_dataset: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<FilterByLastComponentDatasetInst> {
        let op = scope.new_operation("FilterByLastComponentDataset", |builder| {
            builder.add_input(input_dataset);
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(FilterByLastComponentDatasetInst { op })
    }
}
impl FilterByLastComponentDatasetInst {
    /// Returns the 'output' Output of this 'FilterByLastComponentDataset' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_dataset' Input of this 'FilterByLastComponentDataset' operation.
    pub fn input_dataset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<FilterByLastComponentDatasetInst> for crate::Operation {
    fn from(inst: FilterByLastComponentDatasetInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `FilterByLastComponentDataset::new().build(input_dataset, scope)`.
pub fn filter_by_last_component_dataset<O0: ::std::convert::Into<crate::Output>>(
    input_dataset: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    FilterByLastComponentDataset::new().build(input_dataset, scope)
}

/// Builder for the `FilterDataset` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct FilterDataset {
    predicate: ::std::option::Option<::std::string::String>,
    Targuments: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    metadata: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'FilterDataset' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct FilterDatasetInst {
    /// An instance of a fully built FilterDataset Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl FilterDataset {
    /// Creates a new `FilterDataset`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `predicate` attribute.
    pub fn predicate<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.predicate = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Targuments` attribute.
    pub fn Targuments<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Targuments = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `metadata` attribute.
    pub fn metadata<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.metadata = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `FilterDataset` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input_dataset: O0,
        other_arguments: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input_dataset.into(), other_arguments.into(), scope)
    }
    fn build_impl(
        &self,
        input_dataset: crate::Output,
        other_arguments: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("FilterDataset", |nd| {
            nd.add_input(input_dataset);
            nd.add_input(other_arguments);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.predicate {
                nd.set_attr_string("predicate", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Targuments {
                nd.set_attr_type_list("Targuments", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.metadata {
                nd.set_attr_string("metadata", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'FilterDataset' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_dataset: crate::Output,
        other_arguments: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<FilterDatasetInst> {
        let op = scope.new_operation("FilterDataset", |builder| {
            builder.add_input(input_dataset);
            builder.add_input(other_arguments);
            if let ::std::option::Option::Some(value) = &self.predicate {
                builder.set_attr_string("predicate", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Targuments {
                builder.set_attr_type_list("Targuments", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.metadata {
                builder.set_attr_string("metadata", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(FilterDatasetInst { op })
    }
}
impl FilterDatasetInst {
    /// Returns the 'handle' Output of this 'FilterDataset' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_dataset' Input of this 'FilterDataset' operation.
    pub fn input_dataset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'other_arguments' Input of this 'FilterDataset' operation.
    pub fn other_arguments(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<FilterDatasetInst> for crate::Operation {
    fn from(inst: FilterDatasetInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `FilterDataset::new().build(input_dataset, other_arguments, scope)`.
pub fn filter_dataset<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    input_dataset: O0,
    other_arguments: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    FilterDataset::new().build(input_dataset, other_arguments, scope)
}

/// Builder for the `FinalizeDataset` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct FinalizeDataset {
    has_captured_ref: ::std::option::Option<bool>,
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'FinalizeDataset' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct FinalizeDatasetInst {
    /// An instance of a fully built FinalizeDataset Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl FinalizeDataset {
    /// Creates a new `FinalizeDataset`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `has_captured_ref` attribute.
    pub fn has_captured_ref<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.has_captured_ref = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `FinalizeDataset` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input_dataset: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input_dataset.into(), scope)
    }
    fn build_impl(
        &self,
        input_dataset: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("FinalizeDataset", |nd| {
            nd.add_input(input_dataset);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.has_captured_ref {
                nd.set_attr_bool("has_captured_ref", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'FinalizeDataset' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_dataset: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<FinalizeDatasetInst> {
        let op = scope.new_operation("FinalizeDataset", |builder| {
            builder.add_input(input_dataset);
            if let ::std::option::Option::Some(value) = &self.has_captured_ref {
                builder.set_attr_bool("has_captured_ref", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(FinalizeDatasetInst { op })
    }
}
impl FinalizeDatasetInst {
    /// Returns the 'handle' Output of this 'FinalizeDataset' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_dataset' Input of this 'FinalizeDataset' operation.
    pub fn input_dataset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<FinalizeDatasetInst> for crate::Operation {
    fn from(inst: FinalizeDatasetInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `FinalizeDataset::new().build(input_dataset, scope)`.
pub fn finalize_dataset<O0: ::std::convert::Into<crate::Output>>(
    input_dataset: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    FinalizeDataset::new().build(input_dataset, scope)
}

/// Builder for the `FinalizeTPUEmbedding` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct FinalizeTPUEmbedding {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'FinalizeTPUEmbedding' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct FinalizeTPUEmbeddingInst {
    /// An instance of a fully built FinalizeTPUEmbedding Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl FinalizeTPUEmbedding {
    /// Creates a new `FinalizeTPUEmbedding`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `FinalizeTPUEmbedding` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        common_config: O0,
        memory_config: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(common_config.into(), memory_config.into(), scope)
    }
    fn build_impl(
        &self,
        common_config: crate::Output,
        memory_config: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("FinalizeTPUEmbedding", |nd| {
            nd.add_input(common_config);
            nd.add_input(memory_config);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'FinalizeTPUEmbedding' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        common_config: crate::Output,
        memory_config: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<FinalizeTPUEmbeddingInst> {
        let op = scope.new_operation("FinalizeTPUEmbedding", |builder| {
            builder.add_input(common_config);
            builder.add_input(memory_config);
            ::std::result::Result::Ok(())
        })?;
        Ok(FinalizeTPUEmbeddingInst { op })
    }
}
impl FinalizeTPUEmbeddingInst {
    /// Returns the 'common_config' Input of this 'FinalizeTPUEmbedding' operation.
    pub fn common_config(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'memory_config' Input of this 'FinalizeTPUEmbedding' operation.
    pub fn memory_config(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<FinalizeTPUEmbeddingInst> for crate::Operation {
    fn from(inst: FinalizeTPUEmbeddingInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `FinalizeTPUEmbedding::new().build(common_config, memory_config, scope)`.
pub fn finalize_tpuembedding<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    common_config: O0,
    memory_config: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    FinalizeTPUEmbedding::new().build(common_config, memory_config, scope)
}

/// Builder for the `Fingerprint` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Fingerprint {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Fingerprint' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct FingerprintInst {
    /// An instance of a fully built Fingerprint Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Fingerprint {
    /// Creates a new `Fingerprint`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Fingerprint` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        data: O0,
        method: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(data.into(), method.into(), scope)
    }
    fn build_impl(
        &self,
        data: crate::Output,
        method: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Fingerprint", |nd| {
            nd.add_input(data);
            nd.add_input(method);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Fingerprint' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        data: crate::Output,
        method: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<FingerprintInst> {
        let op = scope.new_operation("Fingerprint", |builder| {
            builder.add_input(data);
            builder.add_input(method);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(FingerprintInst { op })
    }
}
impl FingerprintInst {
    /// Returns the 'fingerprint' Output of this 'Fingerprint' operation.
    pub fn fingerprint(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'data' Input of this 'Fingerprint' operation.
    pub fn data(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'method' Input of this 'Fingerprint' operation.
    pub fn method(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<FingerprintInst> for crate::Operation {
    fn from(inst: FingerprintInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Fingerprint::new().build(data, method, scope)`.
pub fn fingerprint<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    data: O0,
    method: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Fingerprint::new().build(data, method, scope)
}

/// Builder for the `FixedLengthRecordDataset` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct FixedLengthRecordDataset {
    metadata: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'FixedLengthRecordDataset' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct FixedLengthRecordDatasetInst {
    /// An instance of a fully built FixedLengthRecordDataset Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl FixedLengthRecordDataset {
    /// Creates a new `FixedLengthRecordDataset`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `metadata` attribute.
    pub fn metadata<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.metadata = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `FixedLengthRecordDataset` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
    >(
        &self,
        filenames: O0,
        header_bytes: O1,
        record_bytes: O2,
        footer_bytes: O3,
        buffer_size: O4,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            filenames.into(),
            header_bytes.into(),
            record_bytes.into(),
            footer_bytes.into(),
            buffer_size.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        filenames: crate::Output,
        header_bytes: crate::Output,
        record_bytes: crate::Output,
        footer_bytes: crate::Output,
        buffer_size: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("FixedLengthRecordDataset", |nd| {
            nd.add_input(filenames);
            nd.add_input(header_bytes);
            nd.add_input(record_bytes);
            nd.add_input(footer_bytes);
            nd.add_input(buffer_size);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.metadata {
                nd.set_attr_string("metadata", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'FixedLengthRecordDataset' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        filenames: crate::Output,
        header_bytes: crate::Output,
        record_bytes: crate::Output,
        footer_bytes: crate::Output,
        buffer_size: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<FixedLengthRecordDatasetInst> {
        let op = scope.new_operation("FixedLengthRecordDataset", |builder| {
            builder.add_input(filenames);
            builder.add_input(header_bytes);
            builder.add_input(record_bytes);
            builder.add_input(footer_bytes);
            builder.add_input(buffer_size);
            if let ::std::option::Option::Some(value) = &self.metadata {
                builder.set_attr_string("metadata", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(FixedLengthRecordDatasetInst { op })
    }
}
impl FixedLengthRecordDatasetInst {
    /// Returns the 'handle' Output of this 'FixedLengthRecordDataset' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'filenames' Input of this 'FixedLengthRecordDataset' operation.
    pub fn filenames(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'header_bytes' Input of this 'FixedLengthRecordDataset' operation.
    pub fn header_bytes(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'record_bytes' Input of this 'FixedLengthRecordDataset' operation.
    pub fn record_bytes(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'footer_bytes' Input of this 'FixedLengthRecordDataset' operation.
    pub fn footer_bytes(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'buffer_size' Input of this 'FixedLengthRecordDataset' operation.
    pub fn buffer_size(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
}
impl From<FixedLengthRecordDatasetInst> for crate::Operation {
    fn from(inst: FixedLengthRecordDatasetInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `FixedLengthRecordDataset::new().build(filenames, header_bytes, record_bytes, footer_bytes, buffer_size, scope)`.
pub fn fixed_length_record_dataset<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
>(
    filenames: O0,
    header_bytes: O1,
    record_bytes: O2,
    footer_bytes: O3,
    buffer_size: O4,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    FixedLengthRecordDataset::new().build(
        filenames,
        header_bytes,
        record_bytes,
        footer_bytes,
        buffer_size,
        scope,
    )
}

/// Builder for the `FixedLengthRecordDatasetV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct FixedLengthRecordDatasetV2 {
    metadata: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'FixedLengthRecordDatasetV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct FixedLengthRecordDatasetV2Inst {
    /// An instance of a fully built FixedLengthRecordDatasetV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl FixedLengthRecordDatasetV2 {
    /// Creates a new `FixedLengthRecordDatasetV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `metadata` attribute.
    pub fn metadata<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.metadata = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `FixedLengthRecordDatasetV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
    >(
        &self,
        filenames: O0,
        header_bytes: O1,
        record_bytes: O2,
        footer_bytes: O3,
        buffer_size: O4,
        compression_type: O5,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            filenames.into(),
            header_bytes.into(),
            record_bytes.into(),
            footer_bytes.into(),
            buffer_size.into(),
            compression_type.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        filenames: crate::Output,
        header_bytes: crate::Output,
        record_bytes: crate::Output,
        footer_bytes: crate::Output,
        buffer_size: crate::Output,
        compression_type: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("FixedLengthRecordDatasetV2", |nd| {
            nd.add_input(filenames);
            nd.add_input(header_bytes);
            nd.add_input(record_bytes);
            nd.add_input(footer_bytes);
            nd.add_input(buffer_size);
            nd.add_input(compression_type);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.metadata {
                nd.set_attr_string("metadata", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'FixedLengthRecordDatasetV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        filenames: crate::Output,
        header_bytes: crate::Output,
        record_bytes: crate::Output,
        footer_bytes: crate::Output,
        buffer_size: crate::Output,
        compression_type: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<FixedLengthRecordDatasetV2Inst> {
        let op = scope.new_operation("FixedLengthRecordDatasetV2", |builder| {
            builder.add_input(filenames);
            builder.add_input(header_bytes);
            builder.add_input(record_bytes);
            builder.add_input(footer_bytes);
            builder.add_input(buffer_size);
            builder.add_input(compression_type);
            if let ::std::option::Option::Some(value) = &self.metadata {
                builder.set_attr_string("metadata", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(FixedLengthRecordDatasetV2Inst { op })
    }
}
impl FixedLengthRecordDatasetV2Inst {
    /// Returns the 'handle' Output of this 'FixedLengthRecordDatasetV2' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'filenames' Input of this 'FixedLengthRecordDatasetV2' operation.
    pub fn filenames(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'header_bytes' Input of this 'FixedLengthRecordDatasetV2' operation.
    pub fn header_bytes(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'record_bytes' Input of this 'FixedLengthRecordDatasetV2' operation.
    pub fn record_bytes(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'footer_bytes' Input of this 'FixedLengthRecordDatasetV2' operation.
    pub fn footer_bytes(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'buffer_size' Input of this 'FixedLengthRecordDatasetV2' operation.
    pub fn buffer_size(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
    /// Returns the 'compression_type' Input of this 'FixedLengthRecordDatasetV2' operation.
    pub fn compression_type(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 5,
        }
    }
}
impl From<FixedLengthRecordDatasetV2Inst> for crate::Operation {
    fn from(inst: FixedLengthRecordDatasetV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `FixedLengthRecordDatasetV2::new().build(filenames, header_bytes, record_bytes, footer_bytes, buffer_size, compression_type, scope)`.
pub fn fixed_length_record_dataset_v2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
>(
    filenames: O0,
    header_bytes: O1,
    record_bytes: O2,
    footer_bytes: O3,
    buffer_size: O4,
    compression_type: O5,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    FixedLengthRecordDatasetV2::new().build(
        filenames,
        header_bytes,
        record_bytes,
        footer_bytes,
        buffer_size,
        compression_type,
        scope,
    )
}

/// Builder for the `FixedLengthRecordReader` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct FixedLengthRecordReader {
    header_bytes: ::std::option::Option<i64>,
    record_bytes: ::std::option::Option<i64>,
    footer_bytes: ::std::option::Option<i64>,
    hop_bytes: ::std::option::Option<i64>,
    container: ::std::option::Option<::std::string::String>,
    shared_name: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'FixedLengthRecordReader' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct FixedLengthRecordReaderInst {
    /// An instance of a fully built FixedLengthRecordReader Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl FixedLengthRecordReader {
    /// Creates a new `FixedLengthRecordReader`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `header_bytes` attribute.
    pub fn header_bytes<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.header_bytes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `record_bytes` attribute.
    pub fn record_bytes<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.record_bytes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `footer_bytes` attribute.
    pub fn footer_bytes<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.footer_bytes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `hop_bytes` attribute.
    pub fn hop_bytes<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.hop_bytes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `container` attribute.
    pub fn container<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.container = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shared_name` attribute.
    pub fn shared_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.shared_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `FixedLengthRecordReader` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("FixedLengthRecordReader", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.header_bytes {
                nd.set_attr_int("header_bytes", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.record_bytes {
                nd.set_attr_int("record_bytes", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.footer_bytes {
                nd.set_attr_int("footer_bytes", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.hop_bytes {
                nd.set_attr_int("hop_bytes", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.container {
                nd.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                nd.set_attr_string("shared_name", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'FixedLengthRecordReader' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        scope: &mut crate::Scope,
    ) -> crate::Result<FixedLengthRecordReaderInst> {
        let op = scope.new_operation("FixedLengthRecordReader", |builder| {
            if let ::std::option::Option::Some(value) = &self.header_bytes {
                builder.set_attr_int("header_bytes", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.record_bytes {
                builder.set_attr_int("record_bytes", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.footer_bytes {
                builder.set_attr_int("footer_bytes", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.hop_bytes {
                builder.set_attr_int("hop_bytes", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.container {
                builder.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                builder.set_attr_string("shared_name", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(FixedLengthRecordReaderInst { op })
    }
}
impl FixedLengthRecordReaderInst {
    /// Returns the 'reader_handle' Output of this 'FixedLengthRecordReader' operation.
    pub fn reader_handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
}
impl From<FixedLengthRecordReaderInst> for crate::Operation {
    fn from(inst: FixedLengthRecordReaderInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `FixedLengthRecordReader::new().build(scope)`.
pub fn fixed_length_record_reader(scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
    FixedLengthRecordReader::new().build(scope)
}

/// Builder for the `FixedLengthRecordReaderV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct FixedLengthRecordReaderV2 {
    header_bytes: ::std::option::Option<i64>,
    record_bytes: ::std::option::Option<i64>,
    footer_bytes: ::std::option::Option<i64>,
    hop_bytes: ::std::option::Option<i64>,
    container: ::std::option::Option<::std::string::String>,
    shared_name: ::std::option::Option<::std::string::String>,
    encoding: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'FixedLengthRecordReaderV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct FixedLengthRecordReaderV2Inst {
    /// An instance of a fully built FixedLengthRecordReaderV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl FixedLengthRecordReaderV2 {
    /// Creates a new `FixedLengthRecordReaderV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `header_bytes` attribute.
    pub fn header_bytes<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.header_bytes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `record_bytes` attribute.
    pub fn record_bytes<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.record_bytes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `footer_bytes` attribute.
    pub fn footer_bytes<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.footer_bytes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `hop_bytes` attribute.
    pub fn hop_bytes<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.hop_bytes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `container` attribute.
    pub fn container<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.container = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shared_name` attribute.
    pub fn shared_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.shared_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `encoding` attribute.
    pub fn encoding<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.encoding = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `FixedLengthRecordReaderV2` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("FixedLengthRecordReaderV2", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.header_bytes {
                nd.set_attr_int("header_bytes", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.record_bytes {
                nd.set_attr_int("record_bytes", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.footer_bytes {
                nd.set_attr_int("footer_bytes", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.hop_bytes {
                nd.set_attr_int("hop_bytes", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.container {
                nd.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                nd.set_attr_string("shared_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.encoding {
                nd.set_attr_string("encoding", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'FixedLengthRecordReaderV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        scope: &mut crate::Scope,
    ) -> crate::Result<FixedLengthRecordReaderV2Inst> {
        let op = scope.new_operation("FixedLengthRecordReaderV2", |builder| {
            if let ::std::option::Option::Some(value) = &self.header_bytes {
                builder.set_attr_int("header_bytes", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.record_bytes {
                builder.set_attr_int("record_bytes", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.footer_bytes {
                builder.set_attr_int("footer_bytes", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.hop_bytes {
                builder.set_attr_int("hop_bytes", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.container {
                builder.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                builder.set_attr_string("shared_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.encoding {
                builder.set_attr_string("encoding", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(FixedLengthRecordReaderV2Inst { op })
    }
}
impl FixedLengthRecordReaderV2Inst {
    /// Returns the 'reader_handle' Output of this 'FixedLengthRecordReaderV2' operation.
    pub fn reader_handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
}
impl From<FixedLengthRecordReaderV2Inst> for crate::Operation {
    fn from(inst: FixedLengthRecordReaderV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `FixedLengthRecordReaderV2::new().build(scope)`.
pub fn fixed_length_record_reader_v2(scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
    FixedLengthRecordReaderV2::new().build(scope)
}

/// Builder for the `FixedUnigramCandidateSampler` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct FixedUnigramCandidateSampler {
    num_true: ::std::option::Option<i64>,
    num_sampled: ::std::option::Option<i64>,
    unique: ::std::option::Option<bool>,
    range_max: ::std::option::Option<i64>,
    vocab_file: ::std::option::Option<::std::string::String>,
    distortion: ::std::option::Option<f32>,
    num_reserved_ids: ::std::option::Option<i64>,
    num_shards: ::std::option::Option<i64>,
    shard: ::std::option::Option<i64>,
    unigrams: ::std::option::Option<::std::vec::Vec<f32>>,
    seed: ::std::option::Option<i64>,
    seed2: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'FixedUnigramCandidateSampler' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct FixedUnigramCandidateSamplerInst {
    /// An instance of a fully built FixedUnigramCandidateSampler Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl FixedUnigramCandidateSampler {
    /// Creates a new `FixedUnigramCandidateSampler`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `num_true` attribute.
    pub fn num_true<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.num_true = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `num_sampled` attribute.
    pub fn num_sampled<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.num_sampled = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `unique` attribute.
    pub fn unique<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.unique = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `range_max` attribute.
    pub fn range_max<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.range_max = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `vocab_file` attribute.
    pub fn vocab_file<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.vocab_file = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `distortion` attribute.
    pub fn distortion<ArgType: ::std::convert::Into<f32>>(mut self, value: ArgType) -> Self {
        self.distortion = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `num_reserved_ids` attribute.
    pub fn num_reserved_ids<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.num_reserved_ids = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `num_shards` attribute.
    pub fn num_shards<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.num_shards = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shard` attribute.
    pub fn shard<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.shard = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `unigrams` attribute.
    pub fn unigrams<ArgType: ::std::convert::Into<::std::vec::Vec<f32>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.unigrams = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `seed` attribute.
    pub fn seed<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.seed = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `seed2` attribute.
    pub fn seed2<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.seed2 = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `FixedUnigramCandidateSampler` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        true_classes: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(true_classes.into(), scope)
    }
    fn build_impl(
        &self,
        true_classes: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("FixedUnigramCandidateSampler", |nd| {
            nd.add_input(true_classes);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.num_true {
                nd.set_attr_int("num_true", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_sampled {
                nd.set_attr_int("num_sampled", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.unique {
                nd.set_attr_bool("unique", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.range_max {
                nd.set_attr_int("range_max", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.vocab_file {
                nd.set_attr_string("vocab_file", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.distortion {
                nd.set_attr_float("distortion", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_reserved_ids {
                nd.set_attr_int("num_reserved_ids", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_shards {
                nd.set_attr_int("num_shards", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shard {
                nd.set_attr_int("shard", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.unigrams {
                nd.set_attr_float_list("unigrams", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed {
                nd.set_attr_int("seed", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed2 {
                nd.set_attr_int("seed2", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'FixedUnigramCandidateSampler' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        true_classes: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<FixedUnigramCandidateSamplerInst> {
        let op = scope.new_operation("FixedUnigramCandidateSampler", |builder| {
            builder.add_input(true_classes);
            if let ::std::option::Option::Some(value) = &self.num_true {
                builder.set_attr_int("num_true", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_sampled {
                builder.set_attr_int("num_sampled", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.unique {
                builder.set_attr_bool("unique", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.range_max {
                builder.set_attr_int("range_max", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.vocab_file {
                builder.set_attr_string("vocab_file", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.distortion {
                builder.set_attr_float("distortion", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_reserved_ids {
                builder.set_attr_int("num_reserved_ids", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_shards {
                builder.set_attr_int("num_shards", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shard {
                builder.set_attr_int("shard", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.unigrams {
                builder.set_attr_float_list("unigrams", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed {
                builder.set_attr_int("seed", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed2 {
                builder.set_attr_int("seed2", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(FixedUnigramCandidateSamplerInst { op })
    }
}
impl FixedUnigramCandidateSamplerInst {
    /// Returns the 'sampled_candidates' Output of this 'FixedUnigramCandidateSampler' operation.
    pub fn sampled_candidates(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'true_expected_count' Output of this 'FixedUnigramCandidateSampler' operation.
    pub fn true_expected_count(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'sampled_expected_count' Output of this 'FixedUnigramCandidateSampler' operation.
    pub fn sampled_expected_count(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns the 'true_classes' Input of this 'FixedUnigramCandidateSampler' operation.
    pub fn true_classes(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<FixedUnigramCandidateSamplerInst> for crate::Operation {
    fn from(inst: FixedUnigramCandidateSamplerInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `FixedUnigramCandidateSampler::new().build(true_classes, scope)`.
pub fn fixed_unigram_candidate_sampler<O0: ::std::convert::Into<crate::Output>>(
    true_classes: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    FixedUnigramCandidateSampler::new().build(true_classes, scope)
}

/// Builder for the `FlatMapDataset` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct FlatMapDataset {
    f: ::std::option::Option<::std::string::String>,
    Targuments: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    metadata: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'FlatMapDataset' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct FlatMapDatasetInst {
    /// An instance of a fully built FlatMapDataset Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl FlatMapDataset {
    /// Creates a new `FlatMapDataset`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `f` attribute.
    pub fn f<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.f = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Targuments` attribute.
    pub fn Targuments<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Targuments = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `metadata` attribute.
    pub fn metadata<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.metadata = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `FlatMapDataset` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input_dataset: O0,
        other_arguments: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input_dataset.into(), other_arguments.into(), scope)
    }
    fn build_impl(
        &self,
        input_dataset: crate::Output,
        other_arguments: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("FlatMapDataset", |nd| {
            nd.add_input(input_dataset);
            nd.add_input(other_arguments);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.f {
                nd.set_attr_string("f", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Targuments {
                nd.set_attr_type_list("Targuments", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.metadata {
                nd.set_attr_string("metadata", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'FlatMapDataset' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_dataset: crate::Output,
        other_arguments: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<FlatMapDatasetInst> {
        let op = scope.new_operation("FlatMapDataset", |builder| {
            builder.add_input(input_dataset);
            builder.add_input(other_arguments);
            if let ::std::option::Option::Some(value) = &self.f {
                builder.set_attr_string("f", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Targuments {
                builder.set_attr_type_list("Targuments", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.metadata {
                builder.set_attr_string("metadata", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(FlatMapDatasetInst { op })
    }
}
impl FlatMapDatasetInst {
    /// Returns the 'handle' Output of this 'FlatMapDataset' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_dataset' Input of this 'FlatMapDataset' operation.
    pub fn input_dataset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'other_arguments' Input of this 'FlatMapDataset' operation.
    pub fn other_arguments(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<FlatMapDatasetInst> for crate::Operation {
    fn from(inst: FlatMapDatasetInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `FlatMapDataset::new().build(input_dataset, other_arguments, scope)`.
pub fn flat_map_dataset<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    input_dataset: O0,
    other_arguments: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    FlatMapDataset::new().build(input_dataset, other_arguments, scope)
}

/// Builder for the `Floor` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Floor {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Floor' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct FloorInst {
    /// An instance of a fully built Floor Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Floor {
    /// Creates a new `Floor`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Floor` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        x: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Floor", |nd| {
            nd.add_input(x);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Floor' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<FloorInst> {
        let op = scope.new_operation("Floor", |builder| {
            builder.add_input(x);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(FloorInst { op })
    }
}
impl FloorInst {
    /// Returns the 'y' Output of this 'Floor' operation.
    pub fn y(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'Floor' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<FloorInst> for crate::Operation {
    fn from(inst: FloorInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Floor::new().build(x, scope)`.
pub fn floor<O0: ::std::convert::Into<crate::Output>>(
    x: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Floor::new().build(x, scope)
}

/// Builder for the `FloorDiv` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct FloorDiv {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'FloorDiv' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct FloorDivInst {
    /// An instance of a fully built FloorDiv Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl FloorDiv {
    /// Creates a new `FloorDiv`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `FloorDiv` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        x: O0,
        y: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), y.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        y: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("FloorDiv", |nd| {
            nd.add_input(x);
            nd.add_input(y);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'FloorDiv' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        y: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<FloorDivInst> {
        let op = scope.new_operation("FloorDiv", |builder| {
            builder.add_input(x);
            builder.add_input(y);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(FloorDivInst { op })
    }
}
impl FloorDivInst {
    /// Returns the 'z' Output of this 'FloorDiv' operation.
    pub fn z(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'FloorDiv' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'y' Input of this 'FloorDiv' operation.
    pub fn y(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<FloorDivInst> for crate::Operation {
    fn from(inst: FloorDivInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `FloorDiv::new().build(x, y, scope)`.
pub fn floor_div<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    x: O0,
    y: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    FloorDiv::new().build(x, y, scope)
}

/// Builder for the `FloorMod` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct FloorMod {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'FloorMod' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct FloorModInst {
    /// An instance of a fully built FloorMod Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl FloorMod {
    /// Creates a new `FloorMod`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `FloorMod` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        x: O0,
        y: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), y.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        y: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("FloorMod", |nd| {
            nd.add_input(x);
            nd.add_input(y);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'FloorMod' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        y: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<FloorModInst> {
        let op = scope.new_operation("FloorMod", |builder| {
            builder.add_input(x);
            builder.add_input(y);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(FloorModInst { op })
    }
}
impl FloorModInst {
    /// Returns the 'z' Output of this 'FloorMod' operation.
    pub fn z(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'FloorMod' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'y' Input of this 'FloorMod' operation.
    pub fn y(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<FloorModInst> for crate::Operation {
    fn from(inst: FloorModInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `FloorMod::new().build(x, y, scope)`.
pub fn floor_mod<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    x: O0,
    y: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    FloorMod::new().build(x, y, scope)
}

/// Builder for the `FlushSummaryWriter` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct FlushSummaryWriter {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'FlushSummaryWriter' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct FlushSummaryWriterInst {
    /// An instance of a fully built FlushSummaryWriter Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl FlushSummaryWriter {
    /// Creates a new `FlushSummaryWriter`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `FlushSummaryWriter` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        writer: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(writer.into(), scope)
    }
    fn build_impl(
        &self,
        writer: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("FlushSummaryWriter", |nd| {
            nd.add_input(writer);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'FlushSummaryWriter' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        writer: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<FlushSummaryWriterInst> {
        let op = scope.new_operation("FlushSummaryWriter", |builder| {
            builder.add_input(writer);
            ::std::result::Result::Ok(())
        })?;
        Ok(FlushSummaryWriterInst { op })
    }
}
impl FlushSummaryWriterInst {
    /// Returns the 'writer' Input of this 'FlushSummaryWriter' operation.
    pub fn writer(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<FlushSummaryWriterInst> for crate::Operation {
    fn from(inst: FlushSummaryWriterInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `FlushSummaryWriter::new().build(writer, scope)`.
pub fn flush_summary_writer<O0: ::std::convert::Into<crate::Output>>(
    writer: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    FlushSummaryWriter::new().build(writer, scope)
}

/// Builder for the `For` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct For {
    T: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    body: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'For' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ForInst {
    /// An instance of a fully built For Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl For {
    /// Creates a new `For`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `body` attribute.
    pub fn body<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.body = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `For` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
    >(
        &self,
        start: O0,
        limit: O1,
        delta: O2,
        input: O3,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            start.into(),
            limit.into(),
            delta.into(),
            input.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        start: crate::Output,
        limit: crate::Output,
        delta: crate::Output,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("For", |nd| {
            nd.add_input(start);
            nd.add_input(limit);
            nd.add_input(delta);
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type_list("T", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.body {
                nd.set_attr_string("body", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'For' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        start: crate::Output,
        limit: crate::Output,
        delta: crate::Output,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ForInst> {
        let op = scope.new_operation("For", |builder| {
            builder.add_input(start);
            builder.add_input(limit);
            builder.add_input(delta);
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type_list("T", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.body {
                builder.set_attr_string("body", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ForInst { op })
    }
}
impl ForInst {
    /// Returns the 'output' Output of this 'For' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'start' Input of this 'For' operation.
    pub fn start(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'limit' Input of this 'For' operation.
    pub fn limit(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'delta' Input of this 'For' operation.
    pub fn delta(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'input' Input of this 'For' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
}
impl From<ForInst> for crate::Operation {
    fn from(inst: ForInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `For::new().build(start, limit, delta, input, scope)`.
pub fn for_<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
>(
    start: O0,
    limit: O1,
    delta: O2,
    input: O3,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    For::new().build(start, limit, delta, input, scope)
}

/// Builder for the `FractionalAvgPool` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct FractionalAvgPool {
    pooling_ratio: ::std::option::Option<::std::vec::Vec<f32>>,
    pseudo_random: ::std::option::Option<bool>,
    overlapping: ::std::option::Option<bool>,
    deterministic: ::std::option::Option<bool>,
    seed: ::std::option::Option<i64>,
    seed2: ::std::option::Option<i64>,
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'FractionalAvgPool' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct FractionalAvgPoolInst {
    /// An instance of a fully built FractionalAvgPool Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl FractionalAvgPool {
    /// Creates a new `FractionalAvgPool`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `pooling_ratio` attribute.
    pub fn pooling_ratio<ArgType: ::std::convert::Into<::std::vec::Vec<f32>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.pooling_ratio = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `pseudo_random` attribute.
    pub fn pseudo_random<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.pseudo_random = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `overlapping` attribute.
    pub fn overlapping<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.overlapping = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `deterministic` attribute.
    pub fn deterministic<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.deterministic = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `seed` attribute.
    pub fn seed<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.seed = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `seed2` attribute.
    pub fn seed2<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.seed2 = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `FractionalAvgPool` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        value: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(value.into(), scope)
    }
    fn build_impl(
        &self,
        value: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("FractionalAvgPool", |nd| {
            nd.add_input(value);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.pooling_ratio {
                nd.set_attr_float_list("pooling_ratio", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.pseudo_random {
                nd.set_attr_bool("pseudo_random", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.overlapping {
                nd.set_attr_bool("overlapping", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.deterministic {
                nd.set_attr_bool("deterministic", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed {
                nd.set_attr_int("seed", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed2 {
                nd.set_attr_int("seed2", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'FractionalAvgPool' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        value: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<FractionalAvgPoolInst> {
        let op = scope.new_operation("FractionalAvgPool", |builder| {
            builder.add_input(value);
            if let ::std::option::Option::Some(value) = &self.pooling_ratio {
                builder.set_attr_float_list("pooling_ratio", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.pseudo_random {
                builder.set_attr_bool("pseudo_random", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.overlapping {
                builder.set_attr_bool("overlapping", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.deterministic {
                builder.set_attr_bool("deterministic", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed {
                builder.set_attr_int("seed", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed2 {
                builder.set_attr_int("seed2", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(FractionalAvgPoolInst { op })
    }
}
impl FractionalAvgPoolInst {
    /// Returns the 'output' Output of this 'FractionalAvgPool' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'row_pooling_sequence' Output of this 'FractionalAvgPool' operation.
    pub fn row_pooling_sequence(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'col_pooling_sequence' Output of this 'FractionalAvgPool' operation.
    pub fn col_pooling_sequence(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns the 'value' Input of this 'FractionalAvgPool' operation.
    pub fn value(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<FractionalAvgPoolInst> for crate::Operation {
    fn from(inst: FractionalAvgPoolInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `FractionalAvgPool::new().build(value, scope)`.
pub fn fractional_avg_pool<O0: ::std::convert::Into<crate::Output>>(
    value: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    FractionalAvgPool::new().build(value, scope)
}

/// Builder for the `FractionalAvgPoolGrad` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct FractionalAvgPoolGrad {
    overlapping: ::std::option::Option<bool>,
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'FractionalAvgPoolGrad' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct FractionalAvgPoolGradInst {
    /// An instance of a fully built FractionalAvgPoolGrad Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl FractionalAvgPoolGrad {
    /// Creates a new `FractionalAvgPoolGrad`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `overlapping` attribute.
    pub fn overlapping<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.overlapping = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `FractionalAvgPoolGrad` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
    >(
        &self,
        orig_input_tensor_shape: O0,
        out_backprop: O1,
        row_pooling_sequence: O2,
        col_pooling_sequence: O3,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            orig_input_tensor_shape.into(),
            out_backprop.into(),
            row_pooling_sequence.into(),
            col_pooling_sequence.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        orig_input_tensor_shape: crate::Output,
        out_backprop: crate::Output,
        row_pooling_sequence: crate::Output,
        col_pooling_sequence: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("FractionalAvgPoolGrad", |nd| {
            nd.add_input(orig_input_tensor_shape);
            nd.add_input(out_backprop);
            nd.add_input(row_pooling_sequence);
            nd.add_input(col_pooling_sequence);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.overlapping {
                nd.set_attr_bool("overlapping", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'FractionalAvgPoolGrad' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        orig_input_tensor_shape: crate::Output,
        out_backprop: crate::Output,
        row_pooling_sequence: crate::Output,
        col_pooling_sequence: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<FractionalAvgPoolGradInst> {
        let op = scope.new_operation("FractionalAvgPoolGrad", |builder| {
            builder.add_input(orig_input_tensor_shape);
            builder.add_input(out_backprop);
            builder.add_input(row_pooling_sequence);
            builder.add_input(col_pooling_sequence);
            if let ::std::option::Option::Some(value) = &self.overlapping {
                builder.set_attr_bool("overlapping", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(FractionalAvgPoolGradInst { op })
    }
}
impl FractionalAvgPoolGradInst {
    /// Returns the 'output' Output of this 'FractionalAvgPoolGrad' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'orig_input_tensor_shape' Input of this 'FractionalAvgPoolGrad' operation.
    pub fn orig_input_tensor_shape(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'out_backprop' Input of this 'FractionalAvgPoolGrad' operation.
    pub fn out_backprop(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'row_pooling_sequence' Input of this 'FractionalAvgPoolGrad' operation.
    pub fn row_pooling_sequence(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'col_pooling_sequence' Input of this 'FractionalAvgPoolGrad' operation.
    pub fn col_pooling_sequence(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
}
impl From<FractionalAvgPoolGradInst> for crate::Operation {
    fn from(inst: FractionalAvgPoolGradInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `FractionalAvgPoolGrad::new().build(orig_input_tensor_shape, out_backprop, row_pooling_sequence, col_pooling_sequence, scope)`.
pub fn fractional_avg_pool_grad<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
>(
    orig_input_tensor_shape: O0,
    out_backprop: O1,
    row_pooling_sequence: O2,
    col_pooling_sequence: O3,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    FractionalAvgPoolGrad::new().build(
        orig_input_tensor_shape,
        out_backprop,
        row_pooling_sequence,
        col_pooling_sequence,
        scope,
    )
}

/// Builder for the `FractionalMaxPool` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct FractionalMaxPool {
    pooling_ratio: ::std::option::Option<::std::vec::Vec<f32>>,
    pseudo_random: ::std::option::Option<bool>,
    overlapping: ::std::option::Option<bool>,
    deterministic: ::std::option::Option<bool>,
    seed: ::std::option::Option<i64>,
    seed2: ::std::option::Option<i64>,
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'FractionalMaxPool' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct FractionalMaxPoolInst {
    /// An instance of a fully built FractionalMaxPool Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl FractionalMaxPool {
    /// Creates a new `FractionalMaxPool`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `pooling_ratio` attribute.
    pub fn pooling_ratio<ArgType: ::std::convert::Into<::std::vec::Vec<f32>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.pooling_ratio = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `pseudo_random` attribute.
    pub fn pseudo_random<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.pseudo_random = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `overlapping` attribute.
    pub fn overlapping<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.overlapping = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `deterministic` attribute.
    pub fn deterministic<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.deterministic = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `seed` attribute.
    pub fn seed<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.seed = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `seed2` attribute.
    pub fn seed2<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.seed2 = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `FractionalMaxPool` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        value: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(value.into(), scope)
    }
    fn build_impl(
        &self,
        value: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("FractionalMaxPool", |nd| {
            nd.add_input(value);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.pooling_ratio {
                nd.set_attr_float_list("pooling_ratio", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.pseudo_random {
                nd.set_attr_bool("pseudo_random", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.overlapping {
                nd.set_attr_bool("overlapping", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.deterministic {
                nd.set_attr_bool("deterministic", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed {
                nd.set_attr_int("seed", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed2 {
                nd.set_attr_int("seed2", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'FractionalMaxPool' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        value: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<FractionalMaxPoolInst> {
        let op = scope.new_operation("FractionalMaxPool", |builder| {
            builder.add_input(value);
            if let ::std::option::Option::Some(value) = &self.pooling_ratio {
                builder.set_attr_float_list("pooling_ratio", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.pseudo_random {
                builder.set_attr_bool("pseudo_random", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.overlapping {
                builder.set_attr_bool("overlapping", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.deterministic {
                builder.set_attr_bool("deterministic", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed {
                builder.set_attr_int("seed", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed2 {
                builder.set_attr_int("seed2", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(FractionalMaxPoolInst { op })
    }
}
impl FractionalMaxPoolInst {
    /// Returns the 'output' Output of this 'FractionalMaxPool' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'row_pooling_sequence' Output of this 'FractionalMaxPool' operation.
    pub fn row_pooling_sequence(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'col_pooling_sequence' Output of this 'FractionalMaxPool' operation.
    pub fn col_pooling_sequence(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns the 'value' Input of this 'FractionalMaxPool' operation.
    pub fn value(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<FractionalMaxPoolInst> for crate::Operation {
    fn from(inst: FractionalMaxPoolInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `FractionalMaxPool::new().build(value, scope)`.
pub fn fractional_max_pool<O0: ::std::convert::Into<crate::Output>>(
    value: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    FractionalMaxPool::new().build(value, scope)
}

/// Builder for the `FractionalMaxPoolGrad` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct FractionalMaxPoolGrad {
    overlapping: ::std::option::Option<bool>,
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'FractionalMaxPoolGrad' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct FractionalMaxPoolGradInst {
    /// An instance of a fully built FractionalMaxPoolGrad Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl FractionalMaxPoolGrad {
    /// Creates a new `FractionalMaxPoolGrad`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `overlapping` attribute.
    pub fn overlapping<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.overlapping = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `FractionalMaxPoolGrad` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
    >(
        &self,
        orig_input: O0,
        orig_output: O1,
        out_backprop: O2,
        row_pooling_sequence: O3,
        col_pooling_sequence: O4,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            orig_input.into(),
            orig_output.into(),
            out_backprop.into(),
            row_pooling_sequence.into(),
            col_pooling_sequence.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        orig_input: crate::Output,
        orig_output: crate::Output,
        out_backprop: crate::Output,
        row_pooling_sequence: crate::Output,
        col_pooling_sequence: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("FractionalMaxPoolGrad", |nd| {
            nd.add_input(orig_input);
            nd.add_input(orig_output);
            nd.add_input(out_backprop);
            nd.add_input(row_pooling_sequence);
            nd.add_input(col_pooling_sequence);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.overlapping {
                nd.set_attr_bool("overlapping", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'FractionalMaxPoolGrad' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        orig_input: crate::Output,
        orig_output: crate::Output,
        out_backprop: crate::Output,
        row_pooling_sequence: crate::Output,
        col_pooling_sequence: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<FractionalMaxPoolGradInst> {
        let op = scope.new_operation("FractionalMaxPoolGrad", |builder| {
            builder.add_input(orig_input);
            builder.add_input(orig_output);
            builder.add_input(out_backprop);
            builder.add_input(row_pooling_sequence);
            builder.add_input(col_pooling_sequence);
            if let ::std::option::Option::Some(value) = &self.overlapping {
                builder.set_attr_bool("overlapping", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(FractionalMaxPoolGradInst { op })
    }
}
impl FractionalMaxPoolGradInst {
    /// Returns the 'output' Output of this 'FractionalMaxPoolGrad' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'orig_input' Input of this 'FractionalMaxPoolGrad' operation.
    pub fn orig_input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'orig_output' Input of this 'FractionalMaxPoolGrad' operation.
    pub fn orig_output(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'out_backprop' Input of this 'FractionalMaxPoolGrad' operation.
    pub fn out_backprop(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'row_pooling_sequence' Input of this 'FractionalMaxPoolGrad' operation.
    pub fn row_pooling_sequence(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'col_pooling_sequence' Input of this 'FractionalMaxPoolGrad' operation.
    pub fn col_pooling_sequence(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
}
impl From<FractionalMaxPoolGradInst> for crate::Operation {
    fn from(inst: FractionalMaxPoolGradInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `FractionalMaxPoolGrad::new().build(orig_input, orig_output, out_backprop, row_pooling_sequence, col_pooling_sequence, scope)`.
pub fn fractional_max_pool_grad<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
>(
    orig_input: O0,
    orig_output: O1,
    out_backprop: O2,
    row_pooling_sequence: O3,
    col_pooling_sequence: O4,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    FractionalMaxPoolGrad::new().build(
        orig_input,
        orig_output,
        out_backprop,
        row_pooling_sequence,
        col_pooling_sequence,
        scope,
    )
}

/// Builder for the `FresnelCos` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct FresnelCos {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'FresnelCos' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct FresnelCosInst {
    /// An instance of a fully built FresnelCos Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl FresnelCos {
    /// Creates a new `FresnelCos`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `FresnelCos` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        x: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("FresnelCos", |nd| {
            nd.add_input(x);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'FresnelCos' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<FresnelCosInst> {
        let op = scope.new_operation("FresnelCos", |builder| {
            builder.add_input(x);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(FresnelCosInst { op })
    }
}
impl FresnelCosInst {
    /// Returns the 'y' Output of this 'FresnelCos' operation.
    pub fn y(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'FresnelCos' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<FresnelCosInst> for crate::Operation {
    fn from(inst: FresnelCosInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `FresnelCos::new().build(x, scope)`.
pub fn fresnel_cos<O0: ::std::convert::Into<crate::Output>>(
    x: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    FresnelCos::new().build(x, scope)
}

/// Builder for the `FresnelSin` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct FresnelSin {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'FresnelSin' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct FresnelSinInst {
    /// An instance of a fully built FresnelSin Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl FresnelSin {
    /// Creates a new `FresnelSin`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `FresnelSin` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        x: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("FresnelSin", |nd| {
            nd.add_input(x);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'FresnelSin' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<FresnelSinInst> {
        let op = scope.new_operation("FresnelSin", |builder| {
            builder.add_input(x);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(FresnelSinInst { op })
    }
}
impl FresnelSinInst {
    /// Returns the 'y' Output of this 'FresnelSin' operation.
    pub fn y(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'FresnelSin' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<FresnelSinInst> for crate::Operation {
    fn from(inst: FresnelSinInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `FresnelSin::new().build(x, scope)`.
pub fn fresnel_sin<O0: ::std::convert::Into<crate::Output>>(
    x: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    FresnelSin::new().build(x, scope)
}

/// Builder for the `FusedBatchNorm` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct FusedBatchNorm {
    T: ::std::option::Option<crate::DataType>,
    epsilon: ::std::option::Option<f32>,
    exponential_avg_factor: ::std::option::Option<f32>,
    data_format: ::std::option::Option<::std::string::String>,
    is_training: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'FusedBatchNorm' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct FusedBatchNormInst {
    /// An instance of a fully built FusedBatchNorm Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl FusedBatchNorm {
    /// Creates a new `FusedBatchNorm`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `epsilon` attribute.
    pub fn epsilon<ArgType: ::std::convert::Into<f32>>(mut self, value: ArgType) -> Self {
        self.epsilon = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `exponential_avg_factor` attribute.
    pub fn exponential_avg_factor<ArgType: ::std::convert::Into<f32>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.exponential_avg_factor = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `data_format` attribute.
    pub fn data_format<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.data_format = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `is_training` attribute.
    pub fn is_training<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.is_training = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `FusedBatchNorm` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
    >(
        &self,
        x: O0,
        scale: O1,
        offset: O2,
        mean: O3,
        variance: O4,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            x.into(),
            scale.into(),
            offset.into(),
            mean.into(),
            variance.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        x: crate::Output,
        scale: crate::Output,
        offset: crate::Output,
        mean: crate::Output,
        variance: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("FusedBatchNorm", |nd| {
            nd.add_input(x);
            nd.add_input(scale);
            nd.add_input(offset);
            nd.add_input(mean);
            nd.add_input(variance);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.epsilon {
                nd.set_attr_float("epsilon", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.exponential_avg_factor {
                nd.set_attr_float("exponential_avg_factor", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.data_format {
                nd.set_attr_string("data_format", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.is_training {
                nd.set_attr_bool("is_training", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'FusedBatchNorm' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        scale: crate::Output,
        offset: crate::Output,
        mean: crate::Output,
        variance: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<FusedBatchNormInst> {
        let op = scope.new_operation("FusedBatchNorm", |builder| {
            builder.add_input(x);
            builder.add_input(scale);
            builder.add_input(offset);
            builder.add_input(mean);
            builder.add_input(variance);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.epsilon {
                builder.set_attr_float("epsilon", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.exponential_avg_factor {
                builder.set_attr_float("exponential_avg_factor", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.data_format {
                builder.set_attr_string("data_format", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.is_training {
                builder.set_attr_bool("is_training", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(FusedBatchNormInst { op })
    }
}
impl FusedBatchNormInst {
    /// Returns the 'y' Output of this 'FusedBatchNorm' operation.
    pub fn y(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'batch_mean' Output of this 'FusedBatchNorm' operation.
    pub fn batch_mean(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'batch_variance' Output of this 'FusedBatchNorm' operation.
    pub fn batch_variance(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns the 'reserve_space_1' Output of this 'FusedBatchNorm' operation.
    pub fn reserve_space_1(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 3,
        }
    }
    /// Returns the 'reserve_space_2' Output of this 'FusedBatchNorm' operation.
    pub fn reserve_space_2(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 4,
        }
    }
    /// Returns the 'x' Input of this 'FusedBatchNorm' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'scale' Input of this 'FusedBatchNorm' operation.
    pub fn scale(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'offset' Input of this 'FusedBatchNorm' operation.
    pub fn offset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'mean' Input of this 'FusedBatchNorm' operation.
    pub fn mean(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'variance' Input of this 'FusedBatchNorm' operation.
    pub fn variance(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
}
impl From<FusedBatchNormInst> for crate::Operation {
    fn from(inst: FusedBatchNormInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `FusedBatchNorm::new().build(x, scale, offset, mean, variance, scope)`.
pub fn fused_batch_norm<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
>(
    x: O0,
    scale: O1,
    offset: O2,
    mean: O3,
    variance: O4,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    FusedBatchNorm::new().build(x, scale, offset, mean, variance, scope)
}

/// Builder for the `FusedBatchNormGrad` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct FusedBatchNormGrad {
    T: ::std::option::Option<crate::DataType>,
    epsilon: ::std::option::Option<f32>,
    data_format: ::std::option::Option<::std::string::String>,
    is_training: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'FusedBatchNormGrad' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct FusedBatchNormGradInst {
    /// An instance of a fully built FusedBatchNormGrad Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl FusedBatchNormGrad {
    /// Creates a new `FusedBatchNormGrad`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `epsilon` attribute.
    pub fn epsilon<ArgType: ::std::convert::Into<f32>>(mut self, value: ArgType) -> Self {
        self.epsilon = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `data_format` attribute.
    pub fn data_format<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.data_format = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `is_training` attribute.
    pub fn is_training<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.is_training = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `FusedBatchNormGrad` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
    >(
        &self,
        y_backprop: O0,
        x: O1,
        scale: O2,
        reserve_space_1: O3,
        reserve_space_2: O4,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            y_backprop.into(),
            x.into(),
            scale.into(),
            reserve_space_1.into(),
            reserve_space_2.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        y_backprop: crate::Output,
        x: crate::Output,
        scale: crate::Output,
        reserve_space_1: crate::Output,
        reserve_space_2: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("FusedBatchNormGrad", |nd| {
            nd.add_input(y_backprop);
            nd.add_input(x);
            nd.add_input(scale);
            nd.add_input(reserve_space_1);
            nd.add_input(reserve_space_2);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.epsilon {
                nd.set_attr_float("epsilon", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.data_format {
                nd.set_attr_string("data_format", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.is_training {
                nd.set_attr_bool("is_training", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'FusedBatchNormGrad' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        y_backprop: crate::Output,
        x: crate::Output,
        scale: crate::Output,
        reserve_space_1: crate::Output,
        reserve_space_2: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<FusedBatchNormGradInst> {
        let op = scope.new_operation("FusedBatchNormGrad", |builder| {
            builder.add_input(y_backprop);
            builder.add_input(x);
            builder.add_input(scale);
            builder.add_input(reserve_space_1);
            builder.add_input(reserve_space_2);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.epsilon {
                builder.set_attr_float("epsilon", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.data_format {
                builder.set_attr_string("data_format", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.is_training {
                builder.set_attr_bool("is_training", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(FusedBatchNormGradInst { op })
    }
}
impl FusedBatchNormGradInst {
    /// Returns the 'x_backprop' Output of this 'FusedBatchNormGrad' operation.
    pub fn x_backprop(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'scale_backprop' Output of this 'FusedBatchNormGrad' operation.
    pub fn scale_backprop(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'offset_backprop' Output of this 'FusedBatchNormGrad' operation.
    pub fn offset_backprop(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns the 'reserve_space_3' Output of this 'FusedBatchNormGrad' operation.
    pub fn reserve_space_3(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 3,
        }
    }
    /// Returns the 'reserve_space_4' Output of this 'FusedBatchNormGrad' operation.
    pub fn reserve_space_4(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 4,
        }
    }
    /// Returns the 'y_backprop' Input of this 'FusedBatchNormGrad' operation.
    pub fn y_backprop(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'FusedBatchNormGrad' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'scale' Input of this 'FusedBatchNormGrad' operation.
    pub fn scale(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'reserve_space_1' Input of this 'FusedBatchNormGrad' operation.
    pub fn reserve_space_1(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'reserve_space_2' Input of this 'FusedBatchNormGrad' operation.
    pub fn reserve_space_2(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
}
impl From<FusedBatchNormGradInst> for crate::Operation {
    fn from(inst: FusedBatchNormGradInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `FusedBatchNormGrad::new().build(y_backprop, x, scale, reserve_space_1, reserve_space_2, scope)`.
pub fn fused_batch_norm_grad<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
>(
    y_backprop: O0,
    x: O1,
    scale: O2,
    reserve_space_1: O3,
    reserve_space_2: O4,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    FusedBatchNormGrad::new().build(
        y_backprop,
        x,
        scale,
        reserve_space_1,
        reserve_space_2,
        scope,
    )
}

/// Builder for the `FusedBatchNormGradV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct FusedBatchNormGradV2 {
    T: ::std::option::Option<crate::DataType>,
    U: ::std::option::Option<crate::DataType>,
    epsilon: ::std::option::Option<f32>,
    data_format: ::std::option::Option<::std::string::String>,
    is_training: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'FusedBatchNormGradV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct FusedBatchNormGradV2Inst {
    /// An instance of a fully built FusedBatchNormGradV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl FusedBatchNormGradV2 {
    /// Creates a new `FusedBatchNormGradV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `U` attribute.
    pub fn U<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.U = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `epsilon` attribute.
    pub fn epsilon<ArgType: ::std::convert::Into<f32>>(mut self, value: ArgType) -> Self {
        self.epsilon = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `data_format` attribute.
    pub fn data_format<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.data_format = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `is_training` attribute.
    pub fn is_training<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.is_training = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `FusedBatchNormGradV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
    >(
        &self,
        y_backprop: O0,
        x: O1,
        scale: O2,
        reserve_space_1: O3,
        reserve_space_2: O4,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            y_backprop.into(),
            x.into(),
            scale.into(),
            reserve_space_1.into(),
            reserve_space_2.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        y_backprop: crate::Output,
        x: crate::Output,
        scale: crate::Output,
        reserve_space_1: crate::Output,
        reserve_space_2: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("FusedBatchNormGradV2", |nd| {
            nd.add_input(y_backprop);
            nd.add_input(x);
            nd.add_input(scale);
            nd.add_input(reserve_space_1);
            nd.add_input(reserve_space_2);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.U {
                nd.set_attr_type("U", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.epsilon {
                nd.set_attr_float("epsilon", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.data_format {
                nd.set_attr_string("data_format", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.is_training {
                nd.set_attr_bool("is_training", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'FusedBatchNormGradV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        y_backprop: crate::Output,
        x: crate::Output,
        scale: crate::Output,
        reserve_space_1: crate::Output,
        reserve_space_2: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<FusedBatchNormGradV2Inst> {
        let op = scope.new_operation("FusedBatchNormGradV2", |builder| {
            builder.add_input(y_backprop);
            builder.add_input(x);
            builder.add_input(scale);
            builder.add_input(reserve_space_1);
            builder.add_input(reserve_space_2);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.U {
                builder.set_attr_type("U", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.epsilon {
                builder.set_attr_float("epsilon", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.data_format {
                builder.set_attr_string("data_format", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.is_training {
                builder.set_attr_bool("is_training", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(FusedBatchNormGradV2Inst { op })
    }
}
impl FusedBatchNormGradV2Inst {
    /// Returns the 'x_backprop' Output of this 'FusedBatchNormGradV2' operation.
    pub fn x_backprop(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'scale_backprop' Output of this 'FusedBatchNormGradV2' operation.
    pub fn scale_backprop(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'offset_backprop' Output of this 'FusedBatchNormGradV2' operation.
    pub fn offset_backprop(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns the 'reserve_space_3' Output of this 'FusedBatchNormGradV2' operation.
    pub fn reserve_space_3(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 3,
        }
    }
    /// Returns the 'reserve_space_4' Output of this 'FusedBatchNormGradV2' operation.
    pub fn reserve_space_4(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 4,
        }
    }
    /// Returns the 'y_backprop' Input of this 'FusedBatchNormGradV2' operation.
    pub fn y_backprop(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'FusedBatchNormGradV2' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'scale' Input of this 'FusedBatchNormGradV2' operation.
    pub fn scale(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'reserve_space_1' Input of this 'FusedBatchNormGradV2' operation.
    pub fn reserve_space_1(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'reserve_space_2' Input of this 'FusedBatchNormGradV2' operation.
    pub fn reserve_space_2(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
}
impl From<FusedBatchNormGradV2Inst> for crate::Operation {
    fn from(inst: FusedBatchNormGradV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `FusedBatchNormGradV2::new().build(y_backprop, x, scale, reserve_space_1, reserve_space_2, scope)`.
pub fn fused_batch_norm_grad_v2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
>(
    y_backprop: O0,
    x: O1,
    scale: O2,
    reserve_space_1: O3,
    reserve_space_2: O4,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    FusedBatchNormGradV2::new().build(
        y_backprop,
        x,
        scale,
        reserve_space_1,
        reserve_space_2,
        scope,
    )
}

/// Builder for the `FusedBatchNormGradV3` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct FusedBatchNormGradV3 {
    T: ::std::option::Option<crate::DataType>,
    U: ::std::option::Option<crate::DataType>,
    epsilon: ::std::option::Option<f32>,
    data_format: ::std::option::Option<::std::string::String>,
    is_training: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'FusedBatchNormGradV3' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct FusedBatchNormGradV3Inst {
    /// An instance of a fully built FusedBatchNormGradV3 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl FusedBatchNormGradV3 {
    /// Creates a new `FusedBatchNormGradV3`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `U` attribute.
    pub fn U<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.U = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `epsilon` attribute.
    pub fn epsilon<ArgType: ::std::convert::Into<f32>>(mut self, value: ArgType) -> Self {
        self.epsilon = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `data_format` attribute.
    pub fn data_format<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.data_format = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `is_training` attribute.
    pub fn is_training<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.is_training = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `FusedBatchNormGradV3` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
    >(
        &self,
        y_backprop: O0,
        x: O1,
        scale: O2,
        reserve_space_1: O3,
        reserve_space_2: O4,
        reserve_space_3: O5,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            y_backprop.into(),
            x.into(),
            scale.into(),
            reserve_space_1.into(),
            reserve_space_2.into(),
            reserve_space_3.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        y_backprop: crate::Output,
        x: crate::Output,
        scale: crate::Output,
        reserve_space_1: crate::Output,
        reserve_space_2: crate::Output,
        reserve_space_3: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("FusedBatchNormGradV3", |nd| {
            nd.add_input(y_backprop);
            nd.add_input(x);
            nd.add_input(scale);
            nd.add_input(reserve_space_1);
            nd.add_input(reserve_space_2);
            nd.add_input(reserve_space_3);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.U {
                nd.set_attr_type("U", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.epsilon {
                nd.set_attr_float("epsilon", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.data_format {
                nd.set_attr_string("data_format", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.is_training {
                nd.set_attr_bool("is_training", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'FusedBatchNormGradV3' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        y_backprop: crate::Output,
        x: crate::Output,
        scale: crate::Output,
        reserve_space_1: crate::Output,
        reserve_space_2: crate::Output,
        reserve_space_3: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<FusedBatchNormGradV3Inst> {
        let op = scope.new_operation("FusedBatchNormGradV3", |builder| {
            builder.add_input(y_backprop);
            builder.add_input(x);
            builder.add_input(scale);
            builder.add_input(reserve_space_1);
            builder.add_input(reserve_space_2);
            builder.add_input(reserve_space_3);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.U {
                builder.set_attr_type("U", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.epsilon {
                builder.set_attr_float("epsilon", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.data_format {
                builder.set_attr_string("data_format", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.is_training {
                builder.set_attr_bool("is_training", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(FusedBatchNormGradV3Inst { op })
    }
}
impl FusedBatchNormGradV3Inst {
    /// Returns the 'x_backprop' Output of this 'FusedBatchNormGradV3' operation.
    pub fn x_backprop(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'scale_backprop' Output of this 'FusedBatchNormGradV3' operation.
    pub fn scale_backprop(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'offset_backprop' Output of this 'FusedBatchNormGradV3' operation.
    pub fn offset_backprop(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns the 'reserve_space_4' Output of this 'FusedBatchNormGradV3' operation.
    pub fn reserve_space_4(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 3,
        }
    }
    /// Returns the 'reserve_space_5' Output of this 'FusedBatchNormGradV3' operation.
    pub fn reserve_space_5(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 4,
        }
    }
    /// Returns the 'y_backprop' Input of this 'FusedBatchNormGradV3' operation.
    pub fn y_backprop(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'FusedBatchNormGradV3' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'scale' Input of this 'FusedBatchNormGradV3' operation.
    pub fn scale(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'reserve_space_1' Input of this 'FusedBatchNormGradV3' operation.
    pub fn reserve_space_1(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'reserve_space_2' Input of this 'FusedBatchNormGradV3' operation.
    pub fn reserve_space_2(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
    /// Returns the 'reserve_space_3' Input of this 'FusedBatchNormGradV3' operation.
    pub fn reserve_space_3(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 5,
        }
    }
}
impl From<FusedBatchNormGradV3Inst> for crate::Operation {
    fn from(inst: FusedBatchNormGradV3Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `FusedBatchNormGradV3::new().build(y_backprop, x, scale, reserve_space_1, reserve_space_2, reserve_space_3, scope)`.
pub fn fused_batch_norm_grad_v3<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
>(
    y_backprop: O0,
    x: O1,
    scale: O2,
    reserve_space_1: O3,
    reserve_space_2: O4,
    reserve_space_3: O5,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    FusedBatchNormGradV3::new().build(
        y_backprop,
        x,
        scale,
        reserve_space_1,
        reserve_space_2,
        reserve_space_3,
        scope,
    )
}

/// Builder for the `FusedBatchNormV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct FusedBatchNormV2 {
    T: ::std::option::Option<crate::DataType>,
    U: ::std::option::Option<crate::DataType>,
    epsilon: ::std::option::Option<f32>,
    exponential_avg_factor: ::std::option::Option<f32>,
    data_format: ::std::option::Option<::std::string::String>,
    is_training: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'FusedBatchNormV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct FusedBatchNormV2Inst {
    /// An instance of a fully built FusedBatchNormV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl FusedBatchNormV2 {
    /// Creates a new `FusedBatchNormV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `U` attribute.
    pub fn U<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.U = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `epsilon` attribute.
    pub fn epsilon<ArgType: ::std::convert::Into<f32>>(mut self, value: ArgType) -> Self {
        self.epsilon = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `exponential_avg_factor` attribute.
    pub fn exponential_avg_factor<ArgType: ::std::convert::Into<f32>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.exponential_avg_factor = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `data_format` attribute.
    pub fn data_format<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.data_format = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `is_training` attribute.
    pub fn is_training<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.is_training = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `FusedBatchNormV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
    >(
        &self,
        x: O0,
        scale: O1,
        offset: O2,
        mean: O3,
        variance: O4,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            x.into(),
            scale.into(),
            offset.into(),
            mean.into(),
            variance.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        x: crate::Output,
        scale: crate::Output,
        offset: crate::Output,
        mean: crate::Output,
        variance: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("FusedBatchNormV2", |nd| {
            nd.add_input(x);
            nd.add_input(scale);
            nd.add_input(offset);
            nd.add_input(mean);
            nd.add_input(variance);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.U {
                nd.set_attr_type("U", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.epsilon {
                nd.set_attr_float("epsilon", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.exponential_avg_factor {
                nd.set_attr_float("exponential_avg_factor", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.data_format {
                nd.set_attr_string("data_format", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.is_training {
                nd.set_attr_bool("is_training", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'FusedBatchNormV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        scale: crate::Output,
        offset: crate::Output,
        mean: crate::Output,
        variance: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<FusedBatchNormV2Inst> {
        let op = scope.new_operation("FusedBatchNormV2", |builder| {
            builder.add_input(x);
            builder.add_input(scale);
            builder.add_input(offset);
            builder.add_input(mean);
            builder.add_input(variance);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.U {
                builder.set_attr_type("U", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.epsilon {
                builder.set_attr_float("epsilon", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.exponential_avg_factor {
                builder.set_attr_float("exponential_avg_factor", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.data_format {
                builder.set_attr_string("data_format", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.is_training {
                builder.set_attr_bool("is_training", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(FusedBatchNormV2Inst { op })
    }
}
impl FusedBatchNormV2Inst {
    /// Returns the 'y' Output of this 'FusedBatchNormV2' operation.
    pub fn y(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'batch_mean' Output of this 'FusedBatchNormV2' operation.
    pub fn batch_mean(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'batch_variance' Output of this 'FusedBatchNormV2' operation.
    pub fn batch_variance(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns the 'reserve_space_1' Output of this 'FusedBatchNormV2' operation.
    pub fn reserve_space_1(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 3,
        }
    }
    /// Returns the 'reserve_space_2' Output of this 'FusedBatchNormV2' operation.
    pub fn reserve_space_2(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 4,
        }
    }
    /// Returns the 'x' Input of this 'FusedBatchNormV2' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'scale' Input of this 'FusedBatchNormV2' operation.
    pub fn scale(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'offset' Input of this 'FusedBatchNormV2' operation.
    pub fn offset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'mean' Input of this 'FusedBatchNormV2' operation.
    pub fn mean(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'variance' Input of this 'FusedBatchNormV2' operation.
    pub fn variance(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
}
impl From<FusedBatchNormV2Inst> for crate::Operation {
    fn from(inst: FusedBatchNormV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `FusedBatchNormV2::new().build(x, scale, offset, mean, variance, scope)`.
pub fn fused_batch_norm_v2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
>(
    x: O0,
    scale: O1,
    offset: O2,
    mean: O3,
    variance: O4,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    FusedBatchNormV2::new().build(x, scale, offset, mean, variance, scope)
}

/// Builder for the `FusedBatchNormV3` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct FusedBatchNormV3 {
    T: ::std::option::Option<crate::DataType>,
    U: ::std::option::Option<crate::DataType>,
    epsilon: ::std::option::Option<f32>,
    exponential_avg_factor: ::std::option::Option<f32>,
    data_format: ::std::option::Option<::std::string::String>,
    is_training: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'FusedBatchNormV3' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct FusedBatchNormV3Inst {
    /// An instance of a fully built FusedBatchNormV3 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl FusedBatchNormV3 {
    /// Creates a new `FusedBatchNormV3`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `U` attribute.
    pub fn U<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.U = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `epsilon` attribute.
    pub fn epsilon<ArgType: ::std::convert::Into<f32>>(mut self, value: ArgType) -> Self {
        self.epsilon = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `exponential_avg_factor` attribute.
    pub fn exponential_avg_factor<ArgType: ::std::convert::Into<f32>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.exponential_avg_factor = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `data_format` attribute.
    pub fn data_format<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.data_format = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `is_training` attribute.
    pub fn is_training<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.is_training = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `FusedBatchNormV3` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
    >(
        &self,
        x: O0,
        scale: O1,
        offset: O2,
        mean: O3,
        variance: O4,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            x.into(),
            scale.into(),
            offset.into(),
            mean.into(),
            variance.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        x: crate::Output,
        scale: crate::Output,
        offset: crate::Output,
        mean: crate::Output,
        variance: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("FusedBatchNormV3", |nd| {
            nd.add_input(x);
            nd.add_input(scale);
            nd.add_input(offset);
            nd.add_input(mean);
            nd.add_input(variance);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.U {
                nd.set_attr_type("U", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.epsilon {
                nd.set_attr_float("epsilon", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.exponential_avg_factor {
                nd.set_attr_float("exponential_avg_factor", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.data_format {
                nd.set_attr_string("data_format", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.is_training {
                nd.set_attr_bool("is_training", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'FusedBatchNormV3' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        scale: crate::Output,
        offset: crate::Output,
        mean: crate::Output,
        variance: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<FusedBatchNormV3Inst> {
        let op = scope.new_operation("FusedBatchNormV3", |builder| {
            builder.add_input(x);
            builder.add_input(scale);
            builder.add_input(offset);
            builder.add_input(mean);
            builder.add_input(variance);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.U {
                builder.set_attr_type("U", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.epsilon {
                builder.set_attr_float("epsilon", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.exponential_avg_factor {
                builder.set_attr_float("exponential_avg_factor", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.data_format {
                builder.set_attr_string("data_format", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.is_training {
                builder.set_attr_bool("is_training", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(FusedBatchNormV3Inst { op })
    }
}
impl FusedBatchNormV3Inst {
    /// Returns the 'y' Output of this 'FusedBatchNormV3' operation.
    pub fn y(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'batch_mean' Output of this 'FusedBatchNormV3' operation.
    pub fn batch_mean(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'batch_variance' Output of this 'FusedBatchNormV3' operation.
    pub fn batch_variance(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns the 'reserve_space_1' Output of this 'FusedBatchNormV3' operation.
    pub fn reserve_space_1(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 3,
        }
    }
    /// Returns the 'reserve_space_2' Output of this 'FusedBatchNormV3' operation.
    pub fn reserve_space_2(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 4,
        }
    }
    /// Returns the 'reserve_space_3' Output of this 'FusedBatchNormV3' operation.
    pub fn reserve_space_3(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 5,
        }
    }
    /// Returns the 'x' Input of this 'FusedBatchNormV3' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'scale' Input of this 'FusedBatchNormV3' operation.
    pub fn scale(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'offset' Input of this 'FusedBatchNormV3' operation.
    pub fn offset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'mean' Input of this 'FusedBatchNormV3' operation.
    pub fn mean(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'variance' Input of this 'FusedBatchNormV3' operation.
    pub fn variance(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
}
impl From<FusedBatchNormV3Inst> for crate::Operation {
    fn from(inst: FusedBatchNormV3Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `FusedBatchNormV3::new().build(x, scale, offset, mean, variance, scope)`.
pub fn fused_batch_norm_v3<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
>(
    x: O0,
    scale: O1,
    offset: O2,
    mean: O3,
    variance: O4,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    FusedBatchNormV3::new().build(x, scale, offset, mean, variance, scope)
}

/// Builder for the `FusedPadConv2D` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct FusedPadConv2D {
    T: ::std::option::Option<crate::DataType>,
    mode: ::std::option::Option<::std::string::String>,
    strides: ::std::option::Option<::std::vec::Vec<i64>>,
    padding: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'FusedPadConv2D' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct FusedPadConv2DInst {
    /// An instance of a fully built FusedPadConv2D Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl FusedPadConv2D {
    /// Creates a new `FusedPadConv2D`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `mode` attribute.
    pub fn mode<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.mode = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `strides` attribute.
    pub fn strides<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.strides = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `padding` attribute.
    pub fn padding<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.padding = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `FusedPadConv2D` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        paddings: O1,
        filter: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), paddings.into(), filter.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        paddings: crate::Output,
        filter: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("FusedPadConv2D", |nd| {
            nd.add_input(input);
            nd.add_input(paddings);
            nd.add_input(filter);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.mode {
                nd.set_attr_string("mode", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.strides {
                nd.set_attr_int_list("strides", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding {
                nd.set_attr_string("padding", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'FusedPadConv2D' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        paddings: crate::Output,
        filter: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<FusedPadConv2DInst> {
        let op = scope.new_operation("FusedPadConv2D", |builder| {
            builder.add_input(input);
            builder.add_input(paddings);
            builder.add_input(filter);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.mode {
                builder.set_attr_string("mode", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.strides {
                builder.set_attr_int_list("strides", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding {
                builder.set_attr_string("padding", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(FusedPadConv2DInst { op })
    }
}
impl FusedPadConv2DInst {
    /// Returns the 'output' Output of this 'FusedPadConv2D' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'FusedPadConv2D' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'paddings' Input of this 'FusedPadConv2D' operation.
    pub fn paddings(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'filter' Input of this 'FusedPadConv2D' operation.
    pub fn filter(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<FusedPadConv2DInst> for crate::Operation {
    fn from(inst: FusedPadConv2DInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `FusedPadConv2D::new().build(input, paddings, filter, scope)`.
pub fn fused_pad_conv2_d<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    input: O0,
    paddings: O1,
    filter: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    FusedPadConv2D::new().build(input, paddings, filter, scope)
}

/// Builder for the `FusedResizeAndPadConv2D` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct FusedResizeAndPadConv2D {
    T: ::std::option::Option<crate::DataType>,
    resize_align_corners: ::std::option::Option<bool>,
    mode: ::std::option::Option<::std::string::String>,
    strides: ::std::option::Option<::std::vec::Vec<i64>>,
    padding: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'FusedResizeAndPadConv2D' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct FusedResizeAndPadConv2DInst {
    /// An instance of a fully built FusedResizeAndPadConv2D Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl FusedResizeAndPadConv2D {
    /// Creates a new `FusedResizeAndPadConv2D`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `resize_align_corners` attribute.
    pub fn resize_align_corners<ArgType: ::std::convert::Into<bool>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.resize_align_corners = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `mode` attribute.
    pub fn mode<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.mode = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `strides` attribute.
    pub fn strides<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.strides = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `padding` attribute.
    pub fn padding<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.padding = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `FusedResizeAndPadConv2D` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        size: O1,
        paddings: O2,
        filter: O3,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            input.into(),
            size.into(),
            paddings.into(),
            filter.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        input: crate::Output,
        size: crate::Output,
        paddings: crate::Output,
        filter: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("FusedResizeAndPadConv2D", |nd| {
            nd.add_input(input);
            nd.add_input(size);
            nd.add_input(paddings);
            nd.add_input(filter);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.resize_align_corners {
                nd.set_attr_bool("resize_align_corners", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.mode {
                nd.set_attr_string("mode", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.strides {
                nd.set_attr_int_list("strides", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding {
                nd.set_attr_string("padding", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'FusedResizeAndPadConv2D' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        size: crate::Output,
        paddings: crate::Output,
        filter: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<FusedResizeAndPadConv2DInst> {
        let op = scope.new_operation("FusedResizeAndPadConv2D", |builder| {
            builder.add_input(input);
            builder.add_input(size);
            builder.add_input(paddings);
            builder.add_input(filter);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.resize_align_corners {
                builder.set_attr_bool("resize_align_corners", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.mode {
                builder.set_attr_string("mode", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.strides {
                builder.set_attr_int_list("strides", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding {
                builder.set_attr_string("padding", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(FusedResizeAndPadConv2DInst { op })
    }
}
impl FusedResizeAndPadConv2DInst {
    /// Returns the 'output' Output of this 'FusedResizeAndPadConv2D' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'FusedResizeAndPadConv2D' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'size' Input of this 'FusedResizeAndPadConv2D' operation.
    pub fn size(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'paddings' Input of this 'FusedResizeAndPadConv2D' operation.
    pub fn paddings(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'filter' Input of this 'FusedResizeAndPadConv2D' operation.
    pub fn filter(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
}
impl From<FusedResizeAndPadConv2DInst> for crate::Operation {
    fn from(inst: FusedResizeAndPadConv2DInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `FusedResizeAndPadConv2D::new().build(input, size, paddings, filter, scope)`.
pub fn fused_resize_and_pad_conv2_d<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
>(
    input: O0,
    size: O1,
    paddings: O2,
    filter: O3,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    FusedResizeAndPadConv2D::new().build(input, size, paddings, filter, scope)
}

/// Builder for the `GRUBlockCell` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct GRUBlockCell {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'GRUBlockCell' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct GRUBlockCellInst {
    /// An instance of a fully built GRUBlockCell Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl GRUBlockCell {
    /// Creates a new `GRUBlockCell`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `GRUBlockCell` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
    >(
        &self,
        x: O0,
        h_prev: O1,
        w_ru: O2,
        w_c: O3,
        b_ru: O4,
        b_c: O5,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            x.into(),
            h_prev.into(),
            w_ru.into(),
            w_c.into(),
            b_ru.into(),
            b_c.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        x: crate::Output,
        h_prev: crate::Output,
        w_ru: crate::Output,
        w_c: crate::Output,
        b_ru: crate::Output,
        b_c: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("GRUBlockCell", |nd| {
            nd.add_input(x);
            nd.add_input(h_prev);
            nd.add_input(w_ru);
            nd.add_input(w_c);
            nd.add_input(b_ru);
            nd.add_input(b_c);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'GRUBlockCell' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        h_prev: crate::Output,
        w_ru: crate::Output,
        w_c: crate::Output,
        b_ru: crate::Output,
        b_c: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<GRUBlockCellInst> {
        let op = scope.new_operation("GRUBlockCell", |builder| {
            builder.add_input(x);
            builder.add_input(h_prev);
            builder.add_input(w_ru);
            builder.add_input(w_c);
            builder.add_input(b_ru);
            builder.add_input(b_c);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(GRUBlockCellInst { op })
    }
}
impl GRUBlockCellInst {
    /// Returns the 'r' Output of this 'GRUBlockCell' operation.
    pub fn r(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'u' Output of this 'GRUBlockCell' operation.
    pub fn u(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'c' Output of this 'GRUBlockCell' operation.
    pub fn c(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns the 'h' Output of this 'GRUBlockCell' operation.
    pub fn h(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 3,
        }
    }
    /// Returns the 'x' Input of this 'GRUBlockCell' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'h_prev' Input of this 'GRUBlockCell' operation.
    pub fn h_prev(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'w_ru' Input of this 'GRUBlockCell' operation.
    pub fn w_ru(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'w_c' Input of this 'GRUBlockCell' operation.
    pub fn w_c(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'b_ru' Input of this 'GRUBlockCell' operation.
    pub fn b_ru(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
    /// Returns the 'b_c' Input of this 'GRUBlockCell' operation.
    pub fn b_c(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 5,
        }
    }
}
impl From<GRUBlockCellInst> for crate::Operation {
    fn from(inst: GRUBlockCellInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `GRUBlockCell::new().build(x, h_prev, w_ru, w_c, b_ru, b_c, scope)`.
pub fn grublock_cell<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
>(
    x: O0,
    h_prev: O1,
    w_ru: O2,
    w_c: O3,
    b_ru: O4,
    b_c: O5,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    GRUBlockCell::new().build(x, h_prev, w_ru, w_c, b_ru, b_c, scope)
}

/// Builder for the `GRUBlockCellGrad` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct GRUBlockCellGrad {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'GRUBlockCellGrad' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct GRUBlockCellGradInst {
    /// An instance of a fully built GRUBlockCellGrad Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl GRUBlockCellGrad {
    /// Creates a new `GRUBlockCellGrad`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `GRUBlockCellGrad` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
        O6: ::std::convert::Into<crate::Output>,
        O7: ::std::convert::Into<crate::Output>,
        O8: ::std::convert::Into<crate::Output>,
        O9: ::std::convert::Into<crate::Output>,
    >(
        &self,
        x: O0,
        h_prev: O1,
        w_ru: O2,
        w_c: O3,
        b_ru: O4,
        b_c: O5,
        r: O6,
        u: O7,
        c: O8,
        d_h: O9,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            x.into(),
            h_prev.into(),
            w_ru.into(),
            w_c.into(),
            b_ru.into(),
            b_c.into(),
            r.into(),
            u.into(),
            c.into(),
            d_h.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        x: crate::Output,
        h_prev: crate::Output,
        w_ru: crate::Output,
        w_c: crate::Output,
        b_ru: crate::Output,
        b_c: crate::Output,
        r: crate::Output,
        u: crate::Output,
        c: crate::Output,
        d_h: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("GRUBlockCellGrad", |nd| {
            nd.add_input(x);
            nd.add_input(h_prev);
            nd.add_input(w_ru);
            nd.add_input(w_c);
            nd.add_input(b_ru);
            nd.add_input(b_c);
            nd.add_input(r);
            nd.add_input(u);
            nd.add_input(c);
            nd.add_input(d_h);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'GRUBlockCellGrad' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        h_prev: crate::Output,
        w_ru: crate::Output,
        w_c: crate::Output,
        b_ru: crate::Output,
        b_c: crate::Output,
        r: crate::Output,
        u: crate::Output,
        c: crate::Output,
        d_h: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<GRUBlockCellGradInst> {
        let op = scope.new_operation("GRUBlockCellGrad", |builder| {
            builder.add_input(x);
            builder.add_input(h_prev);
            builder.add_input(w_ru);
            builder.add_input(w_c);
            builder.add_input(b_ru);
            builder.add_input(b_c);
            builder.add_input(r);
            builder.add_input(u);
            builder.add_input(c);
            builder.add_input(d_h);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(GRUBlockCellGradInst { op })
    }
}
impl GRUBlockCellGradInst {
    /// Returns the 'd_x' Output of this 'GRUBlockCellGrad' operation.
    pub fn d_x(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'd_h_prev' Output of this 'GRUBlockCellGrad' operation.
    pub fn d_h_prev(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'd_c_bar' Output of this 'GRUBlockCellGrad' operation.
    pub fn d_c_bar(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns the 'd_r_bar_u_bar' Output of this 'GRUBlockCellGrad' operation.
    pub fn d_r_bar_u_bar(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 3,
        }
    }
    /// Returns the 'x' Input of this 'GRUBlockCellGrad' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'h_prev' Input of this 'GRUBlockCellGrad' operation.
    pub fn h_prev(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'w_ru' Input of this 'GRUBlockCellGrad' operation.
    pub fn w_ru(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'w_c' Input of this 'GRUBlockCellGrad' operation.
    pub fn w_c(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'b_ru' Input of this 'GRUBlockCellGrad' operation.
    pub fn b_ru(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
    /// Returns the 'b_c' Input of this 'GRUBlockCellGrad' operation.
    pub fn b_c(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 5,
        }
    }
    /// Returns the 'r' Input of this 'GRUBlockCellGrad' operation.
    pub fn r(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 6,
        }
    }
    /// Returns the 'u' Input of this 'GRUBlockCellGrad' operation.
    pub fn u(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 7,
        }
    }
    /// Returns the 'c' Input of this 'GRUBlockCellGrad' operation.
    pub fn c(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 8,
        }
    }
    /// Returns the 'd_h' Input of this 'GRUBlockCellGrad' operation.
    pub fn d_h(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 9,
        }
    }
}
impl From<GRUBlockCellGradInst> for crate::Operation {
    fn from(inst: GRUBlockCellGradInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `GRUBlockCellGrad::new().build(x, h_prev, w_ru, w_c, b_ru, b_c, r, u, c, d_h, scope)`.
pub fn grublock_cell_grad<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
    O6: ::std::convert::Into<crate::Output>,
    O7: ::std::convert::Into<crate::Output>,
    O8: ::std::convert::Into<crate::Output>,
    O9: ::std::convert::Into<crate::Output>,
>(
    x: O0,
    h_prev: O1,
    w_ru: O2,
    w_c: O3,
    b_ru: O4,
    b_c: O5,
    r: O6,
    u: O7,
    c: O8,
    d_h: O9,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    GRUBlockCellGrad::new().build(x, h_prev, w_ru, w_c, b_ru, b_c, r, u, c, d_h, scope)
}

/// Builder for the `Gather` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Gather {
    validate_indices: ::std::option::Option<bool>,
    Tparams: ::std::option::Option<crate::DataType>,
    Tindices: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Gather' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct GatherInst {
    /// An instance of a fully built Gather Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Gather {
    /// Creates a new `Gather`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `validate_indices` attribute.
    pub fn validate_indices<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.validate_indices = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tparams` attribute.
    pub fn Tparams<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tparams = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tindices` attribute.
    pub fn Tindices<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tindices = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Gather` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        params: O0,
        indices: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(params.into(), indices.into(), scope)
    }
    fn build_impl(
        &self,
        params: crate::Output,
        indices: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Gather", |nd| {
            nd.add_input(params);
            nd.add_input(indices);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.validate_indices {
                nd.set_attr_bool("validate_indices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tparams {
                nd.set_attr_type("Tparams", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                nd.set_attr_type("Tindices", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Gather' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        params: crate::Output,
        indices: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<GatherInst> {
        let op = scope.new_operation("Gather", |builder| {
            builder.add_input(params);
            builder.add_input(indices);
            if let ::std::option::Option::Some(value) = &self.validate_indices {
                builder.set_attr_bool("validate_indices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tparams {
                builder.set_attr_type("Tparams", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                builder.set_attr_type("Tindices", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(GatherInst { op })
    }
}
impl GatherInst {
    /// Returns the 'output' Output of this 'Gather' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'params' Input of this 'Gather' operation.
    pub fn params(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'indices' Input of this 'Gather' operation.
    pub fn indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<GatherInst> for crate::Operation {
    fn from(inst: GatherInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Gather::new().build(params, indices, scope)`.
pub fn gather<O0: ::std::convert::Into<crate::Output>, O1: ::std::convert::Into<crate::Output>>(
    params: O0,
    indices: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Gather::new().build(params, indices, scope)
}

/// Builder for the `GatherNd` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct GatherNd {
    Tparams: ::std::option::Option<crate::DataType>,
    Tindices: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'GatherNd' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct GatherNdInst {
    /// An instance of a fully built GatherNd Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl GatherNd {
    /// Creates a new `GatherNd`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `Tparams` attribute.
    pub fn Tparams<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tparams = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tindices` attribute.
    pub fn Tindices<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tindices = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `GatherNd` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        params: O0,
        indices: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(params.into(), indices.into(), scope)
    }
    fn build_impl(
        &self,
        params: crate::Output,
        indices: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("GatherNd", |nd| {
            nd.add_input(params);
            nd.add_input(indices);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.Tparams {
                nd.set_attr_type("Tparams", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                nd.set_attr_type("Tindices", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'GatherNd' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        params: crate::Output,
        indices: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<GatherNdInst> {
        let op = scope.new_operation("GatherNd", |builder| {
            builder.add_input(params);
            builder.add_input(indices);
            if let ::std::option::Option::Some(value) = &self.Tparams {
                builder.set_attr_type("Tparams", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                builder.set_attr_type("Tindices", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(GatherNdInst { op })
    }
}
impl GatherNdInst {
    /// Returns the 'output' Output of this 'GatherNd' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'params' Input of this 'GatherNd' operation.
    pub fn params(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'indices' Input of this 'GatherNd' operation.
    pub fn indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<GatherNdInst> for crate::Operation {
    fn from(inst: GatherNdInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `GatherNd::new().build(params, indices, scope)`.
pub fn gather_nd<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    params: O0,
    indices: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    GatherNd::new().build(params, indices, scope)
}

/// Builder for the `GatherV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct GatherV2 {
    batch_dims: ::std::option::Option<i64>,
    Tparams: ::std::option::Option<crate::DataType>,
    Tindices: ::std::option::Option<crate::DataType>,
    Taxis: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'GatherV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct GatherV2Inst {
    /// An instance of a fully built GatherV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl GatherV2 {
    /// Creates a new `GatherV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `batch_dims` attribute.
    pub fn batch_dims<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.batch_dims = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tparams` attribute.
    pub fn Tparams<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tparams = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tindices` attribute.
    pub fn Tindices<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tindices = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Taxis` attribute.
    pub fn Taxis<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Taxis = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `GatherV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        params: O0,
        indices: O1,
        axis: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(params.into(), indices.into(), axis.into(), scope)
    }
    fn build_impl(
        &self,
        params: crate::Output,
        indices: crate::Output,
        axis: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("GatherV2", |nd| {
            nd.add_input(params);
            nd.add_input(indices);
            nd.add_input(axis);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.batch_dims {
                nd.set_attr_int("batch_dims", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tparams {
                nd.set_attr_type("Tparams", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                nd.set_attr_type("Tindices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Taxis {
                nd.set_attr_type("Taxis", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'GatherV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        params: crate::Output,
        indices: crate::Output,
        axis: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<GatherV2Inst> {
        let op = scope.new_operation("GatherV2", |builder| {
            builder.add_input(params);
            builder.add_input(indices);
            builder.add_input(axis);
            if let ::std::option::Option::Some(value) = &self.batch_dims {
                builder.set_attr_int("batch_dims", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tparams {
                builder.set_attr_type("Tparams", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                builder.set_attr_type("Tindices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Taxis {
                builder.set_attr_type("Taxis", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(GatherV2Inst { op })
    }
}
impl GatherV2Inst {
    /// Returns the 'output' Output of this 'GatherV2' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'params' Input of this 'GatherV2' operation.
    pub fn params(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'indices' Input of this 'GatherV2' operation.
    pub fn indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'axis' Input of this 'GatherV2' operation.
    pub fn axis(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<GatherV2Inst> for crate::Operation {
    fn from(inst: GatherV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `GatherV2::new().build(params, indices, axis, scope)`.
pub fn gather_v2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    params: O0,
    indices: O1,
    axis: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    GatherV2::new().build(params, indices, axis, scope)
}

/// Builder for the `GenerateBoundingBoxProposals` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct GenerateBoundingBoxProposals {
    post_nms_topn: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'GenerateBoundingBoxProposals' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct GenerateBoundingBoxProposalsInst {
    /// An instance of a fully built GenerateBoundingBoxProposals Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl GenerateBoundingBoxProposals {
    /// Creates a new `GenerateBoundingBoxProposals`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `post_nms_topn` attribute.
    pub fn post_nms_topn<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.post_nms_topn = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `GenerateBoundingBoxProposals` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
        O6: ::std::convert::Into<crate::Output>,
    >(
        &self,
        scores: O0,
        bbox_deltas: O1,
        image_info: O2,
        anchors: O3,
        nms_threshold: O4,
        pre_nms_topn: O5,
        min_size: O6,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            scores.into(),
            bbox_deltas.into(),
            image_info.into(),
            anchors.into(),
            nms_threshold.into(),
            pre_nms_topn.into(),
            min_size.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        scores: crate::Output,
        bbox_deltas: crate::Output,
        image_info: crate::Output,
        anchors: crate::Output,
        nms_threshold: crate::Output,
        pre_nms_topn: crate::Output,
        min_size: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("GenerateBoundingBoxProposals", |nd| {
            nd.add_input(scores);
            nd.add_input(bbox_deltas);
            nd.add_input(image_info);
            nd.add_input(anchors);
            nd.add_input(nms_threshold);
            nd.add_input(pre_nms_topn);
            nd.add_input(min_size);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.post_nms_topn {
                nd.set_attr_int("post_nms_topn", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'GenerateBoundingBoxProposals' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        scores: crate::Output,
        bbox_deltas: crate::Output,
        image_info: crate::Output,
        anchors: crate::Output,
        nms_threshold: crate::Output,
        pre_nms_topn: crate::Output,
        min_size: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<GenerateBoundingBoxProposalsInst> {
        let op = scope.new_operation("GenerateBoundingBoxProposals", |builder| {
            builder.add_input(scores);
            builder.add_input(bbox_deltas);
            builder.add_input(image_info);
            builder.add_input(anchors);
            builder.add_input(nms_threshold);
            builder.add_input(pre_nms_topn);
            builder.add_input(min_size);
            if let ::std::option::Option::Some(value) = &self.post_nms_topn {
                builder.set_attr_int("post_nms_topn", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(GenerateBoundingBoxProposalsInst { op })
    }
}
impl GenerateBoundingBoxProposalsInst {
    /// Returns the 'rois' Output of this 'GenerateBoundingBoxProposals' operation.
    pub fn rois(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'roi_probabilities' Output of this 'GenerateBoundingBoxProposals' operation.
    pub fn roi_probabilities(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'scores' Input of this 'GenerateBoundingBoxProposals' operation.
    pub fn scores(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'bbox_deltas' Input of this 'GenerateBoundingBoxProposals' operation.
    pub fn bbox_deltas(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'image_info' Input of this 'GenerateBoundingBoxProposals' operation.
    pub fn image_info(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'anchors' Input of this 'GenerateBoundingBoxProposals' operation.
    pub fn anchors(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'nms_threshold' Input of this 'GenerateBoundingBoxProposals' operation.
    pub fn nms_threshold(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
    /// Returns the 'pre_nms_topn' Input of this 'GenerateBoundingBoxProposals' operation.
    pub fn pre_nms_topn(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 5,
        }
    }
    /// Returns the 'min_size' Input of this 'GenerateBoundingBoxProposals' operation.
    pub fn min_size(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 6,
        }
    }
}
impl From<GenerateBoundingBoxProposalsInst> for crate::Operation {
    fn from(inst: GenerateBoundingBoxProposalsInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `GenerateBoundingBoxProposals::new().build(scores, bbox_deltas, image_info, anchors, nms_threshold, pre_nms_topn, min_size, scope)`.
pub fn generate_bounding_box_proposals<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
    O6: ::std::convert::Into<crate::Output>,
>(
    scores: O0,
    bbox_deltas: O1,
    image_info: O2,
    anchors: O3,
    nms_threshold: O4,
    pre_nms_topn: O5,
    min_size: O6,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    GenerateBoundingBoxProposals::new().build(
        scores,
        bbox_deltas,
        image_info,
        anchors,
        nms_threshold,
        pre_nms_topn,
        min_size,
        scope,
    )
}

/// Builder for the `GenerateVocabRemapping` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct GenerateVocabRemapping {
    new_vocab_offset: ::std::option::Option<i64>,
    num_new_vocab: ::std::option::Option<i64>,
    old_vocab_size: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'GenerateVocabRemapping' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct GenerateVocabRemappingInst {
    /// An instance of a fully built GenerateVocabRemapping Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl GenerateVocabRemapping {
    /// Creates a new `GenerateVocabRemapping`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `new_vocab_offset` attribute.
    pub fn new_vocab_offset<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.new_vocab_offset = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `num_new_vocab` attribute.
    pub fn num_new_vocab<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.num_new_vocab = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `old_vocab_size` attribute.
    pub fn old_vocab_size<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.old_vocab_size = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `GenerateVocabRemapping` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        new_vocab_file: O0,
        old_vocab_file: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(new_vocab_file.into(), old_vocab_file.into(), scope)
    }
    fn build_impl(
        &self,
        new_vocab_file: crate::Output,
        old_vocab_file: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("GenerateVocabRemapping", |nd| {
            nd.add_input(new_vocab_file);
            nd.add_input(old_vocab_file);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.new_vocab_offset {
                nd.set_attr_int("new_vocab_offset", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_new_vocab {
                nd.set_attr_int("num_new_vocab", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.old_vocab_size {
                nd.set_attr_int("old_vocab_size", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'GenerateVocabRemapping' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        new_vocab_file: crate::Output,
        old_vocab_file: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<GenerateVocabRemappingInst> {
        let op = scope.new_operation("GenerateVocabRemapping", |builder| {
            builder.add_input(new_vocab_file);
            builder.add_input(old_vocab_file);
            if let ::std::option::Option::Some(value) = &self.new_vocab_offset {
                builder.set_attr_int("new_vocab_offset", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_new_vocab {
                builder.set_attr_int("num_new_vocab", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.old_vocab_size {
                builder.set_attr_int("old_vocab_size", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(GenerateVocabRemappingInst { op })
    }
}
impl GenerateVocabRemappingInst {
    /// Returns the 'remapping' Output of this 'GenerateVocabRemapping' operation.
    pub fn remapping(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'num_present' Output of this 'GenerateVocabRemapping' operation.
    pub fn num_present(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'new_vocab_file' Input of this 'GenerateVocabRemapping' operation.
    pub fn new_vocab_file(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'old_vocab_file' Input of this 'GenerateVocabRemapping' operation.
    pub fn old_vocab_file(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<GenerateVocabRemappingInst> for crate::Operation {
    fn from(inst: GenerateVocabRemappingInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `GenerateVocabRemapping::new().build(new_vocab_file, old_vocab_file, scope)`.
pub fn generate_vocab_remapping<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    new_vocab_file: O0,
    old_vocab_file: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    GenerateVocabRemapping::new().build(new_vocab_file, old_vocab_file, scope)
}

/// Builder for the `GeneratorDataset` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct GeneratorDataset {
    init_func: ::std::option::Option<::std::string::String>,
    next_func: ::std::option::Option<::std::string::String>,
    finalize_func: ::std::option::Option<::std::string::String>,
    Tinit_func_args: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    Tnext_func_args: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    Tfinalize_func_args: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    metadata: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'GeneratorDataset' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct GeneratorDatasetInst {
    /// An instance of a fully built GeneratorDataset Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl GeneratorDataset {
    /// Creates a new `GeneratorDataset`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `init_func` attribute.
    pub fn init_func<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.init_func = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `next_func` attribute.
    pub fn next_func<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.next_func = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `finalize_func` attribute.
    pub fn finalize_func<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.finalize_func = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tinit_func_args` attribute.
    pub fn Tinit_func_args<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tinit_func_args = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tnext_func_args` attribute.
    pub fn Tnext_func_args<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tnext_func_args = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tfinalize_func_args` attribute.
    pub fn Tfinalize_func_args<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tfinalize_func_args = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `metadata` attribute.
    pub fn metadata<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.metadata = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `GeneratorDataset` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        init_func_other_args: O0,
        next_func_other_args: O1,
        finalize_func_other_args: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            init_func_other_args.into(),
            next_func_other_args.into(),
            finalize_func_other_args.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        init_func_other_args: crate::Output,
        next_func_other_args: crate::Output,
        finalize_func_other_args: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("GeneratorDataset", |nd| {
            nd.add_input(init_func_other_args);
            nd.add_input(next_func_other_args);
            nd.add_input(finalize_func_other_args);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.init_func {
                nd.set_attr_string("init_func", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.next_func {
                nd.set_attr_string("next_func", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.finalize_func {
                nd.set_attr_string("finalize_func", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tinit_func_args {
                nd.set_attr_type_list("Tinit_func_args", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tnext_func_args {
                nd.set_attr_type_list("Tnext_func_args", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tfinalize_func_args {
                nd.set_attr_type_list("Tfinalize_func_args", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.metadata {
                nd.set_attr_string("metadata", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'GeneratorDataset' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        init_func_other_args: crate::Output,
        next_func_other_args: crate::Output,
        finalize_func_other_args: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<GeneratorDatasetInst> {
        let op = scope.new_operation("GeneratorDataset", |builder| {
            builder.add_input(init_func_other_args);
            builder.add_input(next_func_other_args);
            builder.add_input(finalize_func_other_args);
            if let ::std::option::Option::Some(value) = &self.init_func {
                builder.set_attr_string("init_func", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.next_func {
                builder.set_attr_string("next_func", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.finalize_func {
                builder.set_attr_string("finalize_func", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tinit_func_args {
                builder.set_attr_type_list("Tinit_func_args", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tnext_func_args {
                builder.set_attr_type_list("Tnext_func_args", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tfinalize_func_args {
                builder.set_attr_type_list("Tfinalize_func_args", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.metadata {
                builder.set_attr_string("metadata", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(GeneratorDatasetInst { op })
    }
}
impl GeneratorDatasetInst {
    /// Returns the 'handle' Output of this 'GeneratorDataset' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'init_func_other_args' Input of this 'GeneratorDataset' operation.
    pub fn init_func_other_args(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'next_func_other_args' Input of this 'GeneratorDataset' operation.
    pub fn next_func_other_args(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'finalize_func_other_args' Input of this 'GeneratorDataset' operation.
    pub fn finalize_func_other_args(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<GeneratorDatasetInst> for crate::Operation {
    fn from(inst: GeneratorDatasetInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `GeneratorDataset::new().build(init_func_other_args, next_func_other_args, finalize_func_other_args, scope)`.
pub fn generator_dataset<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    init_func_other_args: O0,
    next_func_other_args: O1,
    finalize_func_other_args: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    GeneratorDataset::new().build(
        init_func_other_args,
        next_func_other_args,
        finalize_func_other_args,
        scope,
    )
}

/// Builder for the `GetElementAtIndex` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct GetElementAtIndex {
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'GetElementAtIndex' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct GetElementAtIndexInst {
    /// An instance of a fully built GetElementAtIndex Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl GetElementAtIndex {
    /// Creates a new `GetElementAtIndex`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `GetElementAtIndex` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        dataset: O0,
        index: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(dataset.into(), index.into(), scope)
    }
    fn build_impl(
        &self,
        dataset: crate::Output,
        index: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("GetElementAtIndex", |nd| {
            nd.add_input(dataset);
            nd.add_input(index);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'GetElementAtIndex' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        dataset: crate::Output,
        index: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<GetElementAtIndexInst> {
        let op = scope.new_operation("GetElementAtIndex", |builder| {
            builder.add_input(dataset);
            builder.add_input(index);
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(GetElementAtIndexInst { op })
    }
}
impl GetElementAtIndexInst {
    /// Returns the 'components' Output of this 'GetElementAtIndex' operation.
    pub fn components(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'dataset' Input of this 'GetElementAtIndex' operation.
    pub fn dataset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'index' Input of this 'GetElementAtIndex' operation.
    pub fn index(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<GetElementAtIndexInst> for crate::Operation {
    fn from(inst: GetElementAtIndexInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `GetElementAtIndex::new().build(dataset, index, scope)`.
pub fn get_element_at_index<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    dataset: O0,
    index: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    GetElementAtIndex::new().build(dataset, index, scope)
}

/// Builder for the `GetOptions` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct GetOptions {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'GetOptions' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct GetOptionsInst {
    /// An instance of a fully built GetOptions Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl GetOptions {
    /// Creates a new `GetOptions`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `GetOptions` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input_dataset: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input_dataset.into(), scope)
    }
    fn build_impl(
        &self,
        input_dataset: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("GetOptions", |nd| {
            nd.add_input(input_dataset);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'GetOptions' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_dataset: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<GetOptionsInst> {
        let op = scope.new_operation("GetOptions", |builder| {
            builder.add_input(input_dataset);
            ::std::result::Result::Ok(())
        })?;
        Ok(GetOptionsInst { op })
    }
}
impl GetOptionsInst {
    /// Returns the 'serialized_options' Output of this 'GetOptions' operation.
    pub fn serialized_options(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_dataset' Input of this 'GetOptions' operation.
    pub fn input_dataset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<GetOptionsInst> for crate::Operation {
    fn from(inst: GetOptionsInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `GetOptions::new().build(input_dataset, scope)`.
pub fn get_options<O0: ::std::convert::Into<crate::Output>>(
    input_dataset: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    GetOptions::new().build(input_dataset, scope)
}

/// Builder for the `GetSessionHandle` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct GetSessionHandle {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'GetSessionHandle' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct GetSessionHandleInst {
    /// An instance of a fully built GetSessionHandle Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl GetSessionHandle {
    /// Creates a new `GetSessionHandle`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `GetSessionHandle` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        value: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(value.into(), scope)
    }
    fn build_impl(
        &self,
        value: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("GetSessionHandle", |nd| {
            nd.add_input(value);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'GetSessionHandle' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        value: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<GetSessionHandleInst> {
        let op = scope.new_operation("GetSessionHandle", |builder| {
            builder.add_input(value);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(GetSessionHandleInst { op })
    }
}
impl GetSessionHandleInst {
    /// Returns the 'handle' Output of this 'GetSessionHandle' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'value' Input of this 'GetSessionHandle' operation.
    pub fn value(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<GetSessionHandleInst> for crate::Operation {
    fn from(inst: GetSessionHandleInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `GetSessionHandle::new().build(value, scope)`.
pub fn get_session_handle<O0: ::std::convert::Into<crate::Output>>(
    value: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    GetSessionHandle::new().build(value, scope)
}

/// Builder for the `GetSessionHandleV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct GetSessionHandleV2 {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'GetSessionHandleV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct GetSessionHandleV2Inst {
    /// An instance of a fully built GetSessionHandleV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl GetSessionHandleV2 {
    /// Creates a new `GetSessionHandleV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `GetSessionHandleV2` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        value: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(value.into(), scope)
    }
    fn build_impl(
        &self,
        value: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("GetSessionHandleV2", |nd| {
            nd.add_input(value);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'GetSessionHandleV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        value: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<GetSessionHandleV2Inst> {
        let op = scope.new_operation("GetSessionHandleV2", |builder| {
            builder.add_input(value);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(GetSessionHandleV2Inst { op })
    }
}
impl GetSessionHandleV2Inst {
    /// Returns the 'handle' Output of this 'GetSessionHandleV2' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'value' Input of this 'GetSessionHandleV2' operation.
    pub fn value(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<GetSessionHandleV2Inst> for crate::Operation {
    fn from(inst: GetSessionHandleV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `GetSessionHandleV2::new().build(value, scope)`.
pub fn get_session_handle_v2<O0: ::std::convert::Into<crate::Output>>(
    value: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    GetSessionHandleV2::new().build(value, scope)
}

/// Builder for the `GetSessionTensor` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct GetSessionTensor {
    dtype: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'GetSessionTensor' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct GetSessionTensorInst {
    /// An instance of a fully built GetSessionTensor Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl GetSessionTensor {
    /// Creates a new `GetSessionTensor`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `dtype` attribute.
    pub fn dtype<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `GetSessionTensor` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        handle: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(handle.into(), scope)
    }
    fn build_impl(
        &self,
        handle: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("GetSessionTensor", |nd| {
            nd.add_input(handle);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                nd.set_attr_type("dtype", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'GetSessionTensor' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        handle: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<GetSessionTensorInst> {
        let op = scope.new_operation("GetSessionTensor", |builder| {
            builder.add_input(handle);
            if let ::std::option::Option::Some(value) = &self.dtype {
                builder.set_attr_type("dtype", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(GetSessionTensorInst { op })
    }
}
impl GetSessionTensorInst {
    /// Returns the 'value' Output of this 'GetSessionTensor' operation.
    pub fn value(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'handle' Input of this 'GetSessionTensor' operation.
    pub fn handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<GetSessionTensorInst> for crate::Operation {
    fn from(inst: GetSessionTensorInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `GetSessionTensor::new().build(handle, scope)`.
pub fn get_session_tensor<O0: ::std::convert::Into<crate::Output>>(
    handle: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    GetSessionTensor::new().build(handle, scope)
}

/// Builder for the `Greater` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Greater {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Greater' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct GreaterInst {
    /// An instance of a fully built Greater Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Greater {
    /// Creates a new `Greater`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Greater` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        x: O0,
        y: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), y.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        y: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Greater", |nd| {
            nd.add_input(x);
            nd.add_input(y);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Greater' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        y: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<GreaterInst> {
        let op = scope.new_operation("Greater", |builder| {
            builder.add_input(x);
            builder.add_input(y);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(GreaterInst { op })
    }
}
impl GreaterInst {
    /// Returns the 'z' Output of this 'Greater' operation.
    pub fn z(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'Greater' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'y' Input of this 'Greater' operation.
    pub fn y(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<GreaterInst> for crate::Operation {
    fn from(inst: GreaterInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Greater::new().build(x, y, scope)`.
pub fn greater<O0: ::std::convert::Into<crate::Output>, O1: ::std::convert::Into<crate::Output>>(
    x: O0,
    y: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Greater::new().build(x, y, scope)
}

/// Builder for the `GreaterEqual` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct GreaterEqual {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'GreaterEqual' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct GreaterEqualInst {
    /// An instance of a fully built GreaterEqual Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl GreaterEqual {
    /// Creates a new `GreaterEqual`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `GreaterEqual` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        x: O0,
        y: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), y.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        y: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("GreaterEqual", |nd| {
            nd.add_input(x);
            nd.add_input(y);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'GreaterEqual' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        y: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<GreaterEqualInst> {
        let op = scope.new_operation("GreaterEqual", |builder| {
            builder.add_input(x);
            builder.add_input(y);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(GreaterEqualInst { op })
    }
}
impl GreaterEqualInst {
    /// Returns the 'z' Output of this 'GreaterEqual' operation.
    pub fn z(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'GreaterEqual' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'y' Input of this 'GreaterEqual' operation.
    pub fn y(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<GreaterEqualInst> for crate::Operation {
    fn from(inst: GreaterEqualInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `GreaterEqual::new().build(x, y, scope)`.
pub fn greater_equal<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    x: O0,
    y: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    GreaterEqual::new().build(x, y, scope)
}

/// Builder for the `GroupByReducerDataset` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct GroupByReducerDataset {
    key_func: ::std::option::Option<::std::string::String>,
    init_func: ::std::option::Option<::std::string::String>,
    reduce_func: ::std::option::Option<::std::string::String>,
    finalize_func: ::std::option::Option<::std::string::String>,
    Tkey_func_other_arguments: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    Tinit_func_other_arguments: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    Treduce_func_other_arguments: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    Tfinalize_func_other_arguments: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'GroupByReducerDataset' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct GroupByReducerDatasetInst {
    /// An instance of a fully built GroupByReducerDataset Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl GroupByReducerDataset {
    /// Creates a new `GroupByReducerDataset`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `key_func` attribute.
    pub fn key_func<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.key_func = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `init_func` attribute.
    pub fn init_func<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.init_func = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `reduce_func` attribute.
    pub fn reduce_func<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.reduce_func = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `finalize_func` attribute.
    pub fn finalize_func<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.finalize_func = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tkey_func_other_arguments` attribute.
    pub fn Tkey_func_other_arguments<
        ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>,
    >(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tkey_func_other_arguments = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tinit_func_other_arguments` attribute.
    pub fn Tinit_func_other_arguments<
        ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>,
    >(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tinit_func_other_arguments = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Treduce_func_other_arguments` attribute.
    pub fn Treduce_func_other_arguments<
        ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>,
    >(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Treduce_func_other_arguments = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tfinalize_func_other_arguments` attribute.
    pub fn Tfinalize_func_other_arguments<
        ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>,
    >(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tfinalize_func_other_arguments = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `GroupByReducerDataset` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input_dataset: O0,
        key_func_other_arguments: O1,
        init_func_other_arguments: O2,
        reduce_func_other_arguments: O3,
        finalize_func_other_arguments: O4,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            input_dataset.into(),
            key_func_other_arguments.into(),
            init_func_other_arguments.into(),
            reduce_func_other_arguments.into(),
            finalize_func_other_arguments.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        input_dataset: crate::Output,
        key_func_other_arguments: crate::Output,
        init_func_other_arguments: crate::Output,
        reduce_func_other_arguments: crate::Output,
        finalize_func_other_arguments: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("GroupByReducerDataset", |nd| {
            nd.add_input(input_dataset);
            nd.add_input(key_func_other_arguments);
            nd.add_input(init_func_other_arguments);
            nd.add_input(reduce_func_other_arguments);
            nd.add_input(finalize_func_other_arguments);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.key_func {
                nd.set_attr_string("key_func", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.init_func {
                nd.set_attr_string("init_func", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.reduce_func {
                nd.set_attr_string("reduce_func", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.finalize_func {
                nd.set_attr_string("finalize_func", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tkey_func_other_arguments {
                nd.set_attr_type_list("Tkey_func_other_arguments", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tinit_func_other_arguments {
                nd.set_attr_type_list("Tinit_func_other_arguments", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Treduce_func_other_arguments {
                nd.set_attr_type_list("Treduce_func_other_arguments", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tfinalize_func_other_arguments {
                nd.set_attr_type_list("Tfinalize_func_other_arguments", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'GroupByReducerDataset' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_dataset: crate::Output,
        key_func_other_arguments: crate::Output,
        init_func_other_arguments: crate::Output,
        reduce_func_other_arguments: crate::Output,
        finalize_func_other_arguments: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<GroupByReducerDatasetInst> {
        let op = scope.new_operation("GroupByReducerDataset", |builder| {
            builder.add_input(input_dataset);
            builder.add_input(key_func_other_arguments);
            builder.add_input(init_func_other_arguments);
            builder.add_input(reduce_func_other_arguments);
            builder.add_input(finalize_func_other_arguments);
            if let ::std::option::Option::Some(value) = &self.key_func {
                builder.set_attr_string("key_func", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.init_func {
                builder.set_attr_string("init_func", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.reduce_func {
                builder.set_attr_string("reduce_func", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.finalize_func {
                builder.set_attr_string("finalize_func", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tkey_func_other_arguments {
                builder.set_attr_type_list("Tkey_func_other_arguments", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tinit_func_other_arguments {
                builder.set_attr_type_list("Tinit_func_other_arguments", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Treduce_func_other_arguments {
                builder.set_attr_type_list("Treduce_func_other_arguments", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tfinalize_func_other_arguments {
                builder.set_attr_type_list("Tfinalize_func_other_arguments", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(GroupByReducerDatasetInst { op })
    }
}
impl GroupByReducerDatasetInst {
    /// Returns the 'handle' Output of this 'GroupByReducerDataset' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_dataset' Input of this 'GroupByReducerDataset' operation.
    pub fn input_dataset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'key_func_other_arguments' Input of this 'GroupByReducerDataset' operation.
    pub fn key_func_other_arguments(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'init_func_other_arguments' Input of this 'GroupByReducerDataset' operation.
    pub fn init_func_other_arguments(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'reduce_func_other_arguments' Input of this 'GroupByReducerDataset' operation.
    pub fn reduce_func_other_arguments(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'finalize_func_other_arguments' Input of this 'GroupByReducerDataset' operation.
    pub fn finalize_func_other_arguments(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
}
impl From<GroupByReducerDatasetInst> for crate::Operation {
    fn from(inst: GroupByReducerDatasetInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `GroupByReducerDataset::new().build(input_dataset, key_func_other_arguments, init_func_other_arguments, reduce_func_other_arguments, finalize_func_other_arguments, scope)`.
pub fn group_by_reducer_dataset<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
>(
    input_dataset: O0,
    key_func_other_arguments: O1,
    init_func_other_arguments: O2,
    reduce_func_other_arguments: O3,
    finalize_func_other_arguments: O4,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    GroupByReducerDataset::new().build(
        input_dataset,
        key_func_other_arguments,
        init_func_other_arguments,
        reduce_func_other_arguments,
        finalize_func_other_arguments,
        scope,
    )
}

/// Builder for the `GroupByWindowDataset` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct GroupByWindowDataset {
    key_func: ::std::option::Option<::std::string::String>,
    reduce_func: ::std::option::Option<::std::string::String>,
    window_size_func: ::std::option::Option<::std::string::String>,
    Tkey_func_other_arguments: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    Treduce_func_other_arguments: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    Twindow_size_func_other_arguments: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    metadata: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'GroupByWindowDataset' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct GroupByWindowDatasetInst {
    /// An instance of a fully built GroupByWindowDataset Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl GroupByWindowDataset {
    /// Creates a new `GroupByWindowDataset`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `key_func` attribute.
    pub fn key_func<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.key_func = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `reduce_func` attribute.
    pub fn reduce_func<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.reduce_func = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `window_size_func` attribute.
    pub fn window_size_func<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.window_size_func = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tkey_func_other_arguments` attribute.
    pub fn Tkey_func_other_arguments<
        ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>,
    >(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tkey_func_other_arguments = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Treduce_func_other_arguments` attribute.
    pub fn Treduce_func_other_arguments<
        ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>,
    >(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Treduce_func_other_arguments = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Twindow_size_func_other_arguments` attribute.
    pub fn Twindow_size_func_other_arguments<
        ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>,
    >(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Twindow_size_func_other_arguments = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `metadata` attribute.
    pub fn metadata<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.metadata = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `GroupByWindowDataset` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input_dataset: O0,
        key_func_other_arguments: O1,
        reduce_func_other_arguments: O2,
        window_size_func_other_arguments: O3,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            input_dataset.into(),
            key_func_other_arguments.into(),
            reduce_func_other_arguments.into(),
            window_size_func_other_arguments.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        input_dataset: crate::Output,
        key_func_other_arguments: crate::Output,
        reduce_func_other_arguments: crate::Output,
        window_size_func_other_arguments: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("GroupByWindowDataset", |nd| {
            nd.add_input(input_dataset);
            nd.add_input(key_func_other_arguments);
            nd.add_input(reduce_func_other_arguments);
            nd.add_input(window_size_func_other_arguments);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.key_func {
                nd.set_attr_string("key_func", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.reduce_func {
                nd.set_attr_string("reduce_func", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.window_size_func {
                nd.set_attr_string("window_size_func", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tkey_func_other_arguments {
                nd.set_attr_type_list("Tkey_func_other_arguments", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Treduce_func_other_arguments {
                nd.set_attr_type_list("Treduce_func_other_arguments", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Twindow_size_func_other_arguments {
                nd.set_attr_type_list("Twindow_size_func_other_arguments", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.metadata {
                nd.set_attr_string("metadata", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'GroupByWindowDataset' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_dataset: crate::Output,
        key_func_other_arguments: crate::Output,
        reduce_func_other_arguments: crate::Output,
        window_size_func_other_arguments: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<GroupByWindowDatasetInst> {
        let op = scope.new_operation("GroupByWindowDataset", |builder| {
            builder.add_input(input_dataset);
            builder.add_input(key_func_other_arguments);
            builder.add_input(reduce_func_other_arguments);
            builder.add_input(window_size_func_other_arguments);
            if let ::std::option::Option::Some(value) = &self.key_func {
                builder.set_attr_string("key_func", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.reduce_func {
                builder.set_attr_string("reduce_func", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.window_size_func {
                builder.set_attr_string("window_size_func", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tkey_func_other_arguments {
                builder.set_attr_type_list("Tkey_func_other_arguments", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Treduce_func_other_arguments {
                builder.set_attr_type_list("Treduce_func_other_arguments", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Twindow_size_func_other_arguments {
                builder.set_attr_type_list("Twindow_size_func_other_arguments", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.metadata {
                builder.set_attr_string("metadata", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(GroupByWindowDatasetInst { op })
    }
}
impl GroupByWindowDatasetInst {
    /// Returns the 'handle' Output of this 'GroupByWindowDataset' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_dataset' Input of this 'GroupByWindowDataset' operation.
    pub fn input_dataset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'key_func_other_arguments' Input of this 'GroupByWindowDataset' operation.
    pub fn key_func_other_arguments(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'reduce_func_other_arguments' Input of this 'GroupByWindowDataset' operation.
    pub fn reduce_func_other_arguments(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'window_size_func_other_arguments' Input of this 'GroupByWindowDataset' operation.
    pub fn window_size_func_other_arguments(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
}
impl From<GroupByWindowDatasetInst> for crate::Operation {
    fn from(inst: GroupByWindowDatasetInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `GroupByWindowDataset::new().build(input_dataset, key_func_other_arguments, reduce_func_other_arguments, window_size_func_other_arguments, scope)`.
pub fn group_by_window_dataset<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
>(
    input_dataset: O0,
    key_func_other_arguments: O1,
    reduce_func_other_arguments: O2,
    window_size_func_other_arguments: O3,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    GroupByWindowDataset::new().build(
        input_dataset,
        key_func_other_arguments,
        reduce_func_other_arguments,
        window_size_func_other_arguments,
        scope,
    )
}

/// Builder for the `GuaranteeConst` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct GuaranteeConst {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'GuaranteeConst' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct GuaranteeConstInst {
    /// An instance of a fully built GuaranteeConst Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl GuaranteeConst {
    /// Creates a new `GuaranteeConst`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `GuaranteeConst` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("GuaranteeConst", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'GuaranteeConst' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<GuaranteeConstInst> {
        let op = scope.new_operation("GuaranteeConst", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(GuaranteeConstInst { op })
    }
}
impl GuaranteeConstInst {
    /// Returns the 'output' Output of this 'GuaranteeConst' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'GuaranteeConst' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<GuaranteeConstInst> for crate::Operation {
    fn from(inst: GuaranteeConstInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `GuaranteeConst::new().build(input, scope)`.
pub fn guarantee_const<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    GuaranteeConst::new().build(input, scope)
}

/// Builder for the `HSVToRGB` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct HSVToRGB {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'HSVToRGB' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct HSVToRGBInst {
    /// An instance of a fully built HSVToRGB Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl HSVToRGB {
    /// Creates a new `HSVToRGB`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `HSVToRGB` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        images: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(images.into(), scope)
    }
    fn build_impl(
        &self,
        images: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("HSVToRGB", |nd| {
            nd.add_input(images);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'HSVToRGB' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        images: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<HSVToRGBInst> {
        let op = scope.new_operation("HSVToRGB", |builder| {
            builder.add_input(images);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(HSVToRGBInst { op })
    }
}
impl HSVToRGBInst {
    /// Returns the 'output' Output of this 'HSVToRGB' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'images' Input of this 'HSVToRGB' operation.
    pub fn images(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<HSVToRGBInst> for crate::Operation {
    fn from(inst: HSVToRGBInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `HSVToRGB::new().build(images, scope)`.
pub fn hsvto_rgb<O0: ::std::convert::Into<crate::Output>>(
    images: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    HSVToRGB::new().build(images, scope)
}

/// Builder for the `HashTable` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct HashTable {
    container: ::std::option::Option<::std::string::String>,
    shared_name: ::std::option::Option<::std::string::String>,
    use_node_name_sharing: ::std::option::Option<bool>,
    key_dtype: ::std::option::Option<crate::DataType>,
    value_dtype: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'HashTable' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct HashTableInst {
    /// An instance of a fully built HashTable Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl HashTable {
    /// Creates a new `HashTable`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `container` attribute.
    pub fn container<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.container = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shared_name` attribute.
    pub fn shared_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.shared_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_node_name_sharing` attribute.
    pub fn use_node_name_sharing<ArgType: ::std::convert::Into<bool>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.use_node_name_sharing = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `key_dtype` attribute.
    pub fn key_dtype<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.key_dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `value_dtype` attribute.
    pub fn value_dtype<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.value_dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `HashTable` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("HashTable", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.container {
                nd.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                nd.set_attr_string("shared_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_node_name_sharing {
                nd.set_attr_bool("use_node_name_sharing", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.key_dtype {
                nd.set_attr_type("key_dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.value_dtype {
                nd.set_attr_type("value_dtype", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'HashTable' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(&self, scope: &mut crate::Scope) -> crate::Result<HashTableInst> {
        let op = scope.new_operation("HashTable", |builder| {
            if let ::std::option::Option::Some(value) = &self.container {
                builder.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                builder.set_attr_string("shared_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_node_name_sharing {
                builder.set_attr_bool("use_node_name_sharing", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.key_dtype {
                builder.set_attr_type("key_dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.value_dtype {
                builder.set_attr_type("value_dtype", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(HashTableInst { op })
    }
}
impl HashTableInst {
    /// Returns the 'table_handle' Output of this 'HashTable' operation.
    pub fn table_handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
}
impl From<HashTableInst> for crate::Operation {
    fn from(inst: HashTableInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `HashTable::new().build(scope)`.
pub fn hash_table(scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
    HashTable::new().build(scope)
}

/// Builder for the `HashTableV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct HashTableV2 {
    container: ::std::option::Option<::std::string::String>,
    shared_name: ::std::option::Option<::std::string::String>,
    use_node_name_sharing: ::std::option::Option<bool>,
    key_dtype: ::std::option::Option<crate::DataType>,
    value_dtype: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'HashTableV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct HashTableV2Inst {
    /// An instance of a fully built HashTableV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl HashTableV2 {
    /// Creates a new `HashTableV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `container` attribute.
    pub fn container<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.container = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shared_name` attribute.
    pub fn shared_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.shared_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_node_name_sharing` attribute.
    pub fn use_node_name_sharing<ArgType: ::std::convert::Into<bool>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.use_node_name_sharing = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `key_dtype` attribute.
    pub fn key_dtype<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.key_dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `value_dtype` attribute.
    pub fn value_dtype<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.value_dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `HashTableV2` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("HashTableV2", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.container {
                nd.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                nd.set_attr_string("shared_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_node_name_sharing {
                nd.set_attr_bool("use_node_name_sharing", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.key_dtype {
                nd.set_attr_type("key_dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.value_dtype {
                nd.set_attr_type("value_dtype", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'HashTableV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(&self, scope: &mut crate::Scope) -> crate::Result<HashTableV2Inst> {
        let op = scope.new_operation("HashTableV2", |builder| {
            if let ::std::option::Option::Some(value) = &self.container {
                builder.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                builder.set_attr_string("shared_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_node_name_sharing {
                builder.set_attr_bool("use_node_name_sharing", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.key_dtype {
                builder.set_attr_type("key_dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.value_dtype {
                builder.set_attr_type("value_dtype", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(HashTableV2Inst { op })
    }
}
impl HashTableV2Inst {
    /// Returns the 'table_handle' Output of this 'HashTableV2' operation.
    pub fn table_handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
}
impl From<HashTableV2Inst> for crate::Operation {
    fn from(inst: HashTableV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `HashTableV2::new().build(scope)`.
pub fn hash_table_v2(scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
    HashTableV2::new().build(scope)
}

/// Builder for the `HistogramFixedWidth` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct HistogramFixedWidth {
    T: ::std::option::Option<crate::DataType>,
    dtype: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'HistogramFixedWidth' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct HistogramFixedWidthInst {
    /// An instance of a fully built HistogramFixedWidth Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl HistogramFixedWidth {
    /// Creates a new `HistogramFixedWidth`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `dtype` attribute.
    pub fn dtype<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `HistogramFixedWidth` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        values: O0,
        value_range: O1,
        nbins: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(values.into(), value_range.into(), nbins.into(), scope)
    }
    fn build_impl(
        &self,
        values: crate::Output,
        value_range: crate::Output,
        nbins: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("HistogramFixedWidth", |nd| {
            nd.add_input(values);
            nd.add_input(value_range);
            nd.add_input(nbins);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                nd.set_attr_type("dtype", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'HistogramFixedWidth' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        values: crate::Output,
        value_range: crate::Output,
        nbins: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<HistogramFixedWidthInst> {
        let op = scope.new_operation("HistogramFixedWidth", |builder| {
            builder.add_input(values);
            builder.add_input(value_range);
            builder.add_input(nbins);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                builder.set_attr_type("dtype", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(HistogramFixedWidthInst { op })
    }
}
impl HistogramFixedWidthInst {
    /// Returns the 'out' Output of this 'HistogramFixedWidth' operation.
    pub fn out(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'values' Input of this 'HistogramFixedWidth' operation.
    pub fn values(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'value_range' Input of this 'HistogramFixedWidth' operation.
    pub fn value_range(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'nbins' Input of this 'HistogramFixedWidth' operation.
    pub fn nbins(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<HistogramFixedWidthInst> for crate::Operation {
    fn from(inst: HistogramFixedWidthInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `HistogramFixedWidth::new().build(values, value_range, nbins, scope)`.
pub fn histogram_fixed_width<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    values: O0,
    value_range: O1,
    nbins: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    HistogramFixedWidth::new().build(values, value_range, nbins, scope)
}

/// Builder for the `HistogramSummary` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct HistogramSummary {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'HistogramSummary' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct HistogramSummaryInst {
    /// An instance of a fully built HistogramSummary Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl HistogramSummary {
    /// Creates a new `HistogramSummary`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `HistogramSummary` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        tag: O0,
        values: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(tag.into(), values.into(), scope)
    }
    fn build_impl(
        &self,
        tag: crate::Output,
        values: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("HistogramSummary", |nd| {
            nd.add_input(tag);
            nd.add_input(values);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'HistogramSummary' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        tag: crate::Output,
        values: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<HistogramSummaryInst> {
        let op = scope.new_operation("HistogramSummary", |builder| {
            builder.add_input(tag);
            builder.add_input(values);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(HistogramSummaryInst { op })
    }
}
impl HistogramSummaryInst {
    /// Returns the 'summary' Output of this 'HistogramSummary' operation.
    pub fn summary(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'tag' Input of this 'HistogramSummary' operation.
    pub fn tag(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'values' Input of this 'HistogramSummary' operation.
    pub fn values(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<HistogramSummaryInst> for crate::Operation {
    fn from(inst: HistogramSummaryInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `HistogramSummary::new().build(tag, values, scope)`.
pub fn histogram_summary<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    tag: O0,
    values: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    HistogramSummary::new().build(tag, values, scope)
}

/// Builder for the `HostConst` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct HostConst {
    value: ::std::option::Option<::std::boxed::Box<dyn crate::AnyTensor>>,
    dtype: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'HostConst' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct HostConstInst {
    /// An instance of a fully built HostConst Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl HostConst {
    /// Creates a new `HostConst`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `value` attribute.
    pub fn value<T: crate::TensorType, ArgType: ::std::convert::Into<crate::Tensor<T>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.value = ::std::option::Option::Some(
            (::std::boxed::Box::new(value.into()) as ::std::boxed::Box<dyn crate::AnyTensor>),
        );
        self
    }

    /// Sets the `dtype` attribute.
    pub fn dtype<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `HostConst` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("HostConst", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.value {
                nd.set_attr_any_tensor("value", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                nd.set_attr_type("dtype", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'HostConst' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(&self, scope: &mut crate::Scope) -> crate::Result<HostConstInst> {
        let op = scope.new_operation("HostConst", |builder| {
            if let ::std::option::Option::Some(value) = &self.value {
                builder.set_attr_any_tensor("value", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                builder.set_attr_type("dtype", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(HostConstInst { op })
    }
}
impl HostConstInst {
    /// Returns the 'output' Output of this 'HostConst' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
}
impl From<HostConstInst> for crate::Operation {
    fn from(inst: HostConstInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `HostConst::new().build(scope)`.
pub fn host_const(scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
    HostConst::new().build(scope)
}

/// Builder for the `IFFT` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct IFFT {
    Tcomplex: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'IFFT' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct IFFTInst {
    /// An instance of a fully built IFFT Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl IFFT {
    /// Creates a new `IFFT`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `Tcomplex` attribute.
    pub fn Tcomplex<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tcomplex = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `IFFT` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("IFFT", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.Tcomplex {
                nd.set_attr_type("Tcomplex", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'IFFT' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<IFFTInst> {
        let op = scope.new_operation("IFFT", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.Tcomplex {
                builder.set_attr_type("Tcomplex", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(IFFTInst { op })
    }
}
impl IFFTInst {
    /// Returns the 'output' Output of this 'IFFT' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'IFFT' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<IFFTInst> for crate::Operation {
    fn from(inst: IFFTInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `IFFT::new().build(input, scope)`.
pub fn ifft<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    IFFT::new().build(input, scope)
}

/// Builder for the `IFFT2D` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct IFFT2D {
    Tcomplex: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'IFFT2D' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct IFFT2DInst {
    /// An instance of a fully built IFFT2D Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl IFFT2D {
    /// Creates a new `IFFT2D`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `Tcomplex` attribute.
    pub fn Tcomplex<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tcomplex = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `IFFT2D` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("IFFT2D", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.Tcomplex {
                nd.set_attr_type("Tcomplex", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'IFFT2D' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<IFFT2DInst> {
        let op = scope.new_operation("IFFT2D", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.Tcomplex {
                builder.set_attr_type("Tcomplex", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(IFFT2DInst { op })
    }
}
impl IFFT2DInst {
    /// Returns the 'output' Output of this 'IFFT2D' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'IFFT2D' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<IFFT2DInst> for crate::Operation {
    fn from(inst: IFFT2DInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `IFFT2D::new().build(input, scope)`.
pub fn ifft2_d<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    IFFT2D::new().build(input, scope)
}

/// Builder for the `IFFT3D` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct IFFT3D {
    Tcomplex: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'IFFT3D' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct IFFT3DInst {
    /// An instance of a fully built IFFT3D Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl IFFT3D {
    /// Creates a new `IFFT3D`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `Tcomplex` attribute.
    pub fn Tcomplex<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tcomplex = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `IFFT3D` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("IFFT3D", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.Tcomplex {
                nd.set_attr_type("Tcomplex", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'IFFT3D' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<IFFT3DInst> {
        let op = scope.new_operation("IFFT3D", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.Tcomplex {
                builder.set_attr_type("Tcomplex", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(IFFT3DInst { op })
    }
}
impl IFFT3DInst {
    /// Returns the 'output' Output of this 'IFFT3D' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'IFFT3D' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<IFFT3DInst> for crate::Operation {
    fn from(inst: IFFT3DInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `IFFT3D::new().build(input, scope)`.
pub fn ifft3_d<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    IFFT3D::new().build(input, scope)
}

/// Builder for the `IRFFT` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct IRFFT {
    Treal: ::std::option::Option<crate::DataType>,
    Tcomplex: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'IRFFT' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct IRFFTInst {
    /// An instance of a fully built IRFFT Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl IRFFT {
    /// Creates a new `IRFFT`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `Treal` attribute.
    pub fn Treal<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Treal = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tcomplex` attribute.
    pub fn Tcomplex<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tcomplex = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `IRFFT` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        fft_length: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), fft_length.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        fft_length: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("IRFFT", |nd| {
            nd.add_input(input);
            nd.add_input(fft_length);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.Treal {
                nd.set_attr_type("Treal", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tcomplex {
                nd.set_attr_type("Tcomplex", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'IRFFT' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        fft_length: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<IRFFTInst> {
        let op = scope.new_operation("IRFFT", |builder| {
            builder.add_input(input);
            builder.add_input(fft_length);
            if let ::std::option::Option::Some(value) = &self.Treal {
                builder.set_attr_type("Treal", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tcomplex {
                builder.set_attr_type("Tcomplex", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(IRFFTInst { op })
    }
}
impl IRFFTInst {
    /// Returns the 'output' Output of this 'IRFFT' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'IRFFT' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'fft_length' Input of this 'IRFFT' operation.
    pub fn fft_length(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<IRFFTInst> for crate::Operation {
    fn from(inst: IRFFTInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `IRFFT::new().build(input, fft_length, scope)`.
pub fn irfft<O0: ::std::convert::Into<crate::Output>, O1: ::std::convert::Into<crate::Output>>(
    input: O0,
    fft_length: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    IRFFT::new().build(input, fft_length, scope)
}

/// Builder for the `IRFFT2D` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct IRFFT2D {
    Treal: ::std::option::Option<crate::DataType>,
    Tcomplex: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'IRFFT2D' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct IRFFT2DInst {
    /// An instance of a fully built IRFFT2D Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl IRFFT2D {
    /// Creates a new `IRFFT2D`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `Treal` attribute.
    pub fn Treal<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Treal = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tcomplex` attribute.
    pub fn Tcomplex<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tcomplex = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `IRFFT2D` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        fft_length: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), fft_length.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        fft_length: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("IRFFT2D", |nd| {
            nd.add_input(input);
            nd.add_input(fft_length);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.Treal {
                nd.set_attr_type("Treal", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tcomplex {
                nd.set_attr_type("Tcomplex", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'IRFFT2D' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        fft_length: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<IRFFT2DInst> {
        let op = scope.new_operation("IRFFT2D", |builder| {
            builder.add_input(input);
            builder.add_input(fft_length);
            if let ::std::option::Option::Some(value) = &self.Treal {
                builder.set_attr_type("Treal", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tcomplex {
                builder.set_attr_type("Tcomplex", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(IRFFT2DInst { op })
    }
}
impl IRFFT2DInst {
    /// Returns the 'output' Output of this 'IRFFT2D' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'IRFFT2D' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'fft_length' Input of this 'IRFFT2D' operation.
    pub fn fft_length(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<IRFFT2DInst> for crate::Operation {
    fn from(inst: IRFFT2DInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `IRFFT2D::new().build(input, fft_length, scope)`.
pub fn irfft2_d<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    input: O0,
    fft_length: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    IRFFT2D::new().build(input, fft_length, scope)
}

/// Builder for the `IRFFT3D` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct IRFFT3D {
    Treal: ::std::option::Option<crate::DataType>,
    Tcomplex: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'IRFFT3D' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct IRFFT3DInst {
    /// An instance of a fully built IRFFT3D Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl IRFFT3D {
    /// Creates a new `IRFFT3D`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `Treal` attribute.
    pub fn Treal<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Treal = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tcomplex` attribute.
    pub fn Tcomplex<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tcomplex = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `IRFFT3D` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        fft_length: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), fft_length.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        fft_length: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("IRFFT3D", |nd| {
            nd.add_input(input);
            nd.add_input(fft_length);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.Treal {
                nd.set_attr_type("Treal", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tcomplex {
                nd.set_attr_type("Tcomplex", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'IRFFT3D' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        fft_length: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<IRFFT3DInst> {
        let op = scope.new_operation("IRFFT3D", |builder| {
            builder.add_input(input);
            builder.add_input(fft_length);
            if let ::std::option::Option::Some(value) = &self.Treal {
                builder.set_attr_type("Treal", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tcomplex {
                builder.set_attr_type("Tcomplex", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(IRFFT3DInst { op })
    }
}
impl IRFFT3DInst {
    /// Returns the 'output' Output of this 'IRFFT3D' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'IRFFT3D' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'fft_length' Input of this 'IRFFT3D' operation.
    pub fn fft_length(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<IRFFT3DInst> for crate::Operation {
    fn from(inst: IRFFT3DInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `IRFFT3D::new().build(input, fft_length, scope)`.
pub fn irfft3_d<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    input: O0,
    fft_length: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    IRFFT3D::new().build(input, fft_length, scope)
}

/// Builder for the `Identity` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Identity {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Identity' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct IdentityInst {
    /// An instance of a fully built Identity Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Identity {
    /// Creates a new `Identity`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Identity` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Identity", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Identity' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<IdentityInst> {
        let op = scope.new_operation("Identity", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(IdentityInst { op })
    }
}
impl IdentityInst {
    /// Returns the 'output' Output of this 'Identity' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'Identity' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<IdentityInst> for crate::Operation {
    fn from(inst: IdentityInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Identity::new().build(input, scope)`.
pub fn identity<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Identity::new().build(input, scope)
}

/// Builder for the `IdentityN` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct IdentityN {
    T: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'IdentityN' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct IdentityNInst {
    /// An instance of a fully built IdentityN Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl IdentityN {
    /// Creates a new `IdentityN`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `IdentityN` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("IdentityN", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type_list("T", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'IdentityN' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<IdentityNInst> {
        let op = scope.new_operation("IdentityN", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type_list("T", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(IdentityNInst { op })
    }
}
impl IdentityNInst {
    /// Returns the 'output' Output of this 'IdentityN' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'IdentityN' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<IdentityNInst> for crate::Operation {
    fn from(inst: IdentityNInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `IdentityN::new().build(input, scope)`.
pub fn identity_n<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    IdentityN::new().build(input, scope)
}

/// Builder for the `IdentityReader` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct IdentityReader {
    container: ::std::option::Option<::std::string::String>,
    shared_name: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'IdentityReader' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct IdentityReaderInst {
    /// An instance of a fully built IdentityReader Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl IdentityReader {
    /// Creates a new `IdentityReader`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `container` attribute.
    pub fn container<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.container = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shared_name` attribute.
    pub fn shared_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.shared_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `IdentityReader` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("IdentityReader", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.container {
                nd.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                nd.set_attr_string("shared_name", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'IdentityReader' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(&self, scope: &mut crate::Scope) -> crate::Result<IdentityReaderInst> {
        let op = scope.new_operation("IdentityReader", |builder| {
            if let ::std::option::Option::Some(value) = &self.container {
                builder.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                builder.set_attr_string("shared_name", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(IdentityReaderInst { op })
    }
}
impl IdentityReaderInst {
    /// Returns the 'reader_handle' Output of this 'IdentityReader' operation.
    pub fn reader_handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
}
impl From<IdentityReaderInst> for crate::Operation {
    fn from(inst: IdentityReaderInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `IdentityReader::new().build(scope)`.
pub fn identity_reader(scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
    IdentityReader::new().build(scope)
}

/// Builder for the `IdentityReaderV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct IdentityReaderV2 {
    container: ::std::option::Option<::std::string::String>,
    shared_name: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'IdentityReaderV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct IdentityReaderV2Inst {
    /// An instance of a fully built IdentityReaderV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl IdentityReaderV2 {
    /// Creates a new `IdentityReaderV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `container` attribute.
    pub fn container<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.container = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shared_name` attribute.
    pub fn shared_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.shared_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `IdentityReaderV2` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("IdentityReaderV2", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.container {
                nd.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                nd.set_attr_string("shared_name", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'IdentityReaderV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(&self, scope: &mut crate::Scope) -> crate::Result<IdentityReaderV2Inst> {
        let op = scope.new_operation("IdentityReaderV2", |builder| {
            if let ::std::option::Option::Some(value) = &self.container {
                builder.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                builder.set_attr_string("shared_name", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(IdentityReaderV2Inst { op })
    }
}
impl IdentityReaderV2Inst {
    /// Returns the 'reader_handle' Output of this 'IdentityReaderV2' operation.
    pub fn reader_handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
}
impl From<IdentityReaderV2Inst> for crate::Operation {
    fn from(inst: IdentityReaderV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `IdentityReaderV2::new().build(scope)`.
pub fn identity_reader_v2(scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
    IdentityReaderV2::new().build(scope)
}

/// Builder for the `If` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct If {
    Tcond: ::std::option::Option<crate::DataType>,
    Tin: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    Tout: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    then_branch: ::std::option::Option<::std::string::String>,
    else_branch: ::std::option::Option<::std::string::String>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'If' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct IfInst {
    /// An instance of a fully built If Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl If {
    /// Creates a new `If`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `Tcond` attribute.
    pub fn Tcond<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Tcond = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tin` attribute.
    pub fn Tin<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tin = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tout` attribute.
    pub fn Tout<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tout = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `then_branch` attribute.
    pub fn then_branch<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.then_branch = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `else_branch` attribute.
    pub fn else_branch<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.else_branch = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `If` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        cond: O0,
        input: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(cond.into(), input.into(), scope)
    }
    fn build_impl(
        &self,
        cond: crate::Output,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("If", |nd| {
            nd.add_input(cond);
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.Tcond {
                nd.set_attr_type("Tcond", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tin {
                nd.set_attr_type_list("Tin", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tout {
                nd.set_attr_type_list("Tout", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.then_branch {
                nd.set_attr_string("then_branch", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.else_branch {
                nd.set_attr_string("else_branch", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'If' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        cond: crate::Output,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<IfInst> {
        let op = scope.new_operation("If", |builder| {
            builder.add_input(cond);
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.Tcond {
                builder.set_attr_type("Tcond", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tin {
                builder.set_attr_type_list("Tin", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tout {
                builder.set_attr_type_list("Tout", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.then_branch {
                builder.set_attr_string("then_branch", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.else_branch {
                builder.set_attr_string("else_branch", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(IfInst { op })
    }
}
impl IfInst {
    /// Returns the 'output' Output of this 'If' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'cond' Input of this 'If' operation.
    pub fn cond(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'If' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<IfInst> for crate::Operation {
    fn from(inst: IfInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `If::new().build(cond, input, scope)`.
pub fn if_<O0: ::std::convert::Into<crate::Output>, O1: ::std::convert::Into<crate::Output>>(
    cond: O0,
    input: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    If::new().build(cond, input, scope)
}

/// Builder for the `Igamma` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Igamma {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Igamma' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct IgammaInst {
    /// An instance of a fully built Igamma Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Igamma {
    /// Creates a new `Igamma`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Igamma` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        a: O0,
        x: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(a.into(), x.into(), scope)
    }
    fn build_impl(
        &self,
        a: crate::Output,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Igamma", |nd| {
            nd.add_input(a);
            nd.add_input(x);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Igamma' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        a: crate::Output,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<IgammaInst> {
        let op = scope.new_operation("Igamma", |builder| {
            builder.add_input(a);
            builder.add_input(x);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(IgammaInst { op })
    }
}
impl IgammaInst {
    /// Returns the 'z' Output of this 'Igamma' operation.
    pub fn z(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'a' Input of this 'Igamma' operation.
    pub fn a(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'Igamma' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<IgammaInst> for crate::Operation {
    fn from(inst: IgammaInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Igamma::new().build(a, x, scope)`.
pub fn igamma<O0: ::std::convert::Into<crate::Output>, O1: ::std::convert::Into<crate::Output>>(
    a: O0,
    x: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Igamma::new().build(a, x, scope)
}

/// Builder for the `IgammaGradA` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct IgammaGradA {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'IgammaGradA' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct IgammaGradAInst {
    /// An instance of a fully built IgammaGradA Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl IgammaGradA {
    /// Creates a new `IgammaGradA`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `IgammaGradA` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        a: O0,
        x: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(a.into(), x.into(), scope)
    }
    fn build_impl(
        &self,
        a: crate::Output,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("IgammaGradA", |nd| {
            nd.add_input(a);
            nd.add_input(x);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'IgammaGradA' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        a: crate::Output,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<IgammaGradAInst> {
        let op = scope.new_operation("IgammaGradA", |builder| {
            builder.add_input(a);
            builder.add_input(x);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(IgammaGradAInst { op })
    }
}
impl IgammaGradAInst {
    /// Returns the 'z' Output of this 'IgammaGradA' operation.
    pub fn z(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'a' Input of this 'IgammaGradA' operation.
    pub fn a(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'IgammaGradA' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<IgammaGradAInst> for crate::Operation {
    fn from(inst: IgammaGradAInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `IgammaGradA::new().build(a, x, scope)`.
pub fn igamma_grad_a<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    a: O0,
    x: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    IgammaGradA::new().build(a, x, scope)
}

/// Builder for the `Igammac` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Igammac {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Igammac' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct IgammacInst {
    /// An instance of a fully built Igammac Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Igammac {
    /// Creates a new `Igammac`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Igammac` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        a: O0,
        x: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(a.into(), x.into(), scope)
    }
    fn build_impl(
        &self,
        a: crate::Output,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Igammac", |nd| {
            nd.add_input(a);
            nd.add_input(x);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Igammac' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        a: crate::Output,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<IgammacInst> {
        let op = scope.new_operation("Igammac", |builder| {
            builder.add_input(a);
            builder.add_input(x);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(IgammacInst { op })
    }
}
impl IgammacInst {
    /// Returns the 'z' Output of this 'Igammac' operation.
    pub fn z(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'a' Input of this 'Igammac' operation.
    pub fn a(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'Igammac' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<IgammacInst> for crate::Operation {
    fn from(inst: IgammacInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Igammac::new().build(a, x, scope)`.
pub fn igammac<O0: ::std::convert::Into<crate::Output>, O1: ::std::convert::Into<crate::Output>>(
    a: O0,
    x: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Igammac::new().build(a, x, scope)
}

/// Builder for the `IgnoreErrorsDataset` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct IgnoreErrorsDataset {
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    log_warning: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'IgnoreErrorsDataset' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct IgnoreErrorsDatasetInst {
    /// An instance of a fully built IgnoreErrorsDataset Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl IgnoreErrorsDataset {
    /// Creates a new `IgnoreErrorsDataset`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `log_warning` attribute.
    pub fn log_warning<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.log_warning = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `IgnoreErrorsDataset` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input_dataset: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input_dataset.into(), scope)
    }
    fn build_impl(
        &self,
        input_dataset: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("IgnoreErrorsDataset", |nd| {
            nd.add_input(input_dataset);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.log_warning {
                nd.set_attr_bool("log_warning", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'IgnoreErrorsDataset' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_dataset: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<IgnoreErrorsDatasetInst> {
        let op = scope.new_operation("IgnoreErrorsDataset", |builder| {
            builder.add_input(input_dataset);
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.log_warning {
                builder.set_attr_bool("log_warning", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(IgnoreErrorsDatasetInst { op })
    }
}
impl IgnoreErrorsDatasetInst {
    /// Returns the 'handle' Output of this 'IgnoreErrorsDataset' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_dataset' Input of this 'IgnoreErrorsDataset' operation.
    pub fn input_dataset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<IgnoreErrorsDatasetInst> for crate::Operation {
    fn from(inst: IgnoreErrorsDatasetInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `IgnoreErrorsDataset::new().build(input_dataset, scope)`.
pub fn ignore_errors_dataset<O0: ::std::convert::Into<crate::Output>>(
    input_dataset: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    IgnoreErrorsDataset::new().build(input_dataset, scope)
}

/// Builder for the `Imag` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Imag {
    T: ::std::option::Option<crate::DataType>,
    Tout: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Imag' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ImagInst {
    /// An instance of a fully built Imag Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Imag {
    /// Creates a new `Imag`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tout` attribute.
    pub fn Tout<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Tout = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Imag` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Imag", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tout {
                nd.set_attr_type("Tout", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Imag' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ImagInst> {
        let op = scope.new_operation("Imag", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tout {
                builder.set_attr_type("Tout", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ImagInst { op })
    }
}
impl ImagInst {
    /// Returns the 'output' Output of this 'Imag' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'Imag' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<ImagInst> for crate::Operation {
    fn from(inst: ImagInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Imag::new().build(input, scope)`.
pub fn imag<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Imag::new().build(input, scope)
}

/// Builder for the `ImageProjectiveTransformV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ImageProjectiveTransformV2 {
    dtype: ::std::option::Option<crate::DataType>,
    interpolation: ::std::option::Option<::std::string::String>,
    fill_mode: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ImageProjectiveTransformV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ImageProjectiveTransformV2Inst {
    /// An instance of a fully built ImageProjectiveTransformV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ImageProjectiveTransformV2 {
    /// Creates a new `ImageProjectiveTransformV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `dtype` attribute.
    pub fn dtype<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `interpolation` attribute.
    pub fn interpolation<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.interpolation = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `fill_mode` attribute.
    pub fn fill_mode<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.fill_mode = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ImageProjectiveTransformV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        images: O0,
        transforms: O1,
        output_shape: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(images.into(), transforms.into(), output_shape.into(), scope)
    }
    fn build_impl(
        &self,
        images: crate::Output,
        transforms: crate::Output,
        output_shape: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ImageProjectiveTransformV2", |nd| {
            nd.add_input(images);
            nd.add_input(transforms);
            nd.add_input(output_shape);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                nd.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.interpolation {
                nd.set_attr_string("interpolation", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.fill_mode {
                nd.set_attr_string("fill_mode", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ImageProjectiveTransformV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        images: crate::Output,
        transforms: crate::Output,
        output_shape: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ImageProjectiveTransformV2Inst> {
        let op = scope.new_operation("ImageProjectiveTransformV2", |builder| {
            builder.add_input(images);
            builder.add_input(transforms);
            builder.add_input(output_shape);
            if let ::std::option::Option::Some(value) = &self.dtype {
                builder.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.interpolation {
                builder.set_attr_string("interpolation", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.fill_mode {
                builder.set_attr_string("fill_mode", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ImageProjectiveTransformV2Inst { op })
    }
}
impl ImageProjectiveTransformV2Inst {
    /// Returns the 'transformed_images' Output of this 'ImageProjectiveTransformV2' operation.
    pub fn transformed_images(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'images' Input of this 'ImageProjectiveTransformV2' operation.
    pub fn images(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'transforms' Input of this 'ImageProjectiveTransformV2' operation.
    pub fn transforms(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'output_shape' Input of this 'ImageProjectiveTransformV2' operation.
    pub fn output_shape(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<ImageProjectiveTransformV2Inst> for crate::Operation {
    fn from(inst: ImageProjectiveTransformV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ImageProjectiveTransformV2::new().build(images, transforms, output_shape, scope)`.
pub fn image_projective_transform_v2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    images: O0,
    transforms: O1,
    output_shape: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ImageProjectiveTransformV2::new().build(images, transforms, output_shape, scope)
}

/// Builder for the `ImageProjectiveTransformV3` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ImageProjectiveTransformV3 {
    dtype: ::std::option::Option<crate::DataType>,
    interpolation: ::std::option::Option<::std::string::String>,
    fill_mode: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ImageProjectiveTransformV3' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ImageProjectiveTransformV3Inst {
    /// An instance of a fully built ImageProjectiveTransformV3 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ImageProjectiveTransformV3 {
    /// Creates a new `ImageProjectiveTransformV3`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `dtype` attribute.
    pub fn dtype<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `interpolation` attribute.
    pub fn interpolation<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.interpolation = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `fill_mode` attribute.
    pub fn fill_mode<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.fill_mode = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ImageProjectiveTransformV3` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
    >(
        &self,
        images: O0,
        transforms: O1,
        output_shape: O2,
        fill_value: O3,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            images.into(),
            transforms.into(),
            output_shape.into(),
            fill_value.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        images: crate::Output,
        transforms: crate::Output,
        output_shape: crate::Output,
        fill_value: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ImageProjectiveTransformV3", |nd| {
            nd.add_input(images);
            nd.add_input(transforms);
            nd.add_input(output_shape);
            nd.add_input(fill_value);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                nd.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.interpolation {
                nd.set_attr_string("interpolation", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.fill_mode {
                nd.set_attr_string("fill_mode", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ImageProjectiveTransformV3' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        images: crate::Output,
        transforms: crate::Output,
        output_shape: crate::Output,
        fill_value: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ImageProjectiveTransformV3Inst> {
        let op = scope.new_operation("ImageProjectiveTransformV3", |builder| {
            builder.add_input(images);
            builder.add_input(transforms);
            builder.add_input(output_shape);
            builder.add_input(fill_value);
            if let ::std::option::Option::Some(value) = &self.dtype {
                builder.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.interpolation {
                builder.set_attr_string("interpolation", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.fill_mode {
                builder.set_attr_string("fill_mode", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ImageProjectiveTransformV3Inst { op })
    }
}
impl ImageProjectiveTransformV3Inst {
    /// Returns the 'transformed_images' Output of this 'ImageProjectiveTransformV3' operation.
    pub fn transformed_images(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'images' Input of this 'ImageProjectiveTransformV3' operation.
    pub fn images(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'transforms' Input of this 'ImageProjectiveTransformV3' operation.
    pub fn transforms(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'output_shape' Input of this 'ImageProjectiveTransformV3' operation.
    pub fn output_shape(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'fill_value' Input of this 'ImageProjectiveTransformV3' operation.
    pub fn fill_value(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
}
impl From<ImageProjectiveTransformV3Inst> for crate::Operation {
    fn from(inst: ImageProjectiveTransformV3Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ImageProjectiveTransformV3::new().build(images, transforms, output_shape, fill_value, scope)`.
pub fn image_projective_transform_v3<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
>(
    images: O0,
    transforms: O1,
    output_shape: O2,
    fill_value: O3,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ImageProjectiveTransformV3::new().build(images, transforms, output_shape, fill_value, scope)
}

/// Builder for the `ImageSummary` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ImageSummary {
    max_images: ::std::option::Option<i64>,
    T: ::std::option::Option<crate::DataType>,
    bad_color: ::std::option::Option<::std::boxed::Box<dyn crate::AnyTensor>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ImageSummary' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ImageSummaryInst {
    /// An instance of a fully built ImageSummary Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ImageSummary {
    /// Creates a new `ImageSummary`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `max_images` attribute.
    pub fn max_images<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.max_images = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `bad_color` attribute.
    pub fn bad_color<T: crate::TensorType, ArgType: ::std::convert::Into<crate::Tensor<T>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.bad_color = ::std::option::Option::Some(
            (::std::boxed::Box::new(value.into()) as ::std::boxed::Box<dyn crate::AnyTensor>),
        );
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ImageSummary` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        tag: O0,
        tensor: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(tag.into(), tensor.into(), scope)
    }
    fn build_impl(
        &self,
        tag: crate::Output,
        tensor: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ImageSummary", |nd| {
            nd.add_input(tag);
            nd.add_input(tensor);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.max_images {
                nd.set_attr_int("max_images", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.bad_color {
                nd.set_attr_any_tensor("bad_color", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ImageSummary' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        tag: crate::Output,
        tensor: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ImageSummaryInst> {
        let op = scope.new_operation("ImageSummary", |builder| {
            builder.add_input(tag);
            builder.add_input(tensor);
            if let ::std::option::Option::Some(value) = &self.max_images {
                builder.set_attr_int("max_images", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.bad_color {
                builder.set_attr_any_tensor("bad_color", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ImageSummaryInst { op })
    }
}
impl ImageSummaryInst {
    /// Returns the 'summary' Output of this 'ImageSummary' operation.
    pub fn summary(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'tag' Input of this 'ImageSummary' operation.
    pub fn tag(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'tensor' Input of this 'ImageSummary' operation.
    pub fn tensor(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<ImageSummaryInst> for crate::Operation {
    fn from(inst: ImageSummaryInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ImageSummary::new().build(tag, tensor, scope)`.
pub fn image_summary<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    tag: O0,
    tensor: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ImageSummary::new().build(tag, tensor, scope)
}

/// Builder for the `ImmutableConst` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ImmutableConst {
    dtype: ::std::option::Option<crate::DataType>,
    shape: ::std::option::Option<crate::Shape>,
    memory_region_name: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ImmutableConst' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ImmutableConstInst {
    /// An instance of a fully built ImmutableConst Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ImmutableConst {
    /// Creates a new `ImmutableConst`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `dtype` attribute.
    pub fn dtype<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shape` attribute.
    pub fn shape<ArgType: ::std::convert::Into<crate::Shape>>(mut self, value: ArgType) -> Self {
        self.shape = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `memory_region_name` attribute.
    pub fn memory_region_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.memory_region_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ImmutableConst` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("ImmutableConst", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                nd.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shape {
                nd.set_attr_shape("shape", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.memory_region_name {
                nd.set_attr_string("memory_region_name", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ImmutableConst' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(&self, scope: &mut crate::Scope) -> crate::Result<ImmutableConstInst> {
        let op = scope.new_operation("ImmutableConst", |builder| {
            if let ::std::option::Option::Some(value) = &self.dtype {
                builder.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shape {
                builder.set_attr_shape("shape", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.memory_region_name {
                builder.set_attr_string("memory_region_name", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ImmutableConstInst { op })
    }
}
impl ImmutableConstInst {
    /// Returns the 'tensor' Output of this 'ImmutableConst' operation.
    pub fn tensor(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
}
impl From<ImmutableConstInst> for crate::Operation {
    fn from(inst: ImmutableConstInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ImmutableConst::new().build(scope)`.
pub fn immutable_const(scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
    ImmutableConst::new().build(scope)
}

/// Builder for the `ImportEvent` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ImportEvent {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ImportEvent' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ImportEventInst {
    /// An instance of a fully built ImportEvent Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ImportEvent {
    /// Creates a new `ImportEvent`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ImportEvent` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        writer: O0,
        event: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(writer.into(), event.into(), scope)
    }
    fn build_impl(
        &self,
        writer: crate::Output,
        event: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ImportEvent", |nd| {
            nd.add_input(writer);
            nd.add_input(event);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ImportEvent' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        writer: crate::Output,
        event: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ImportEventInst> {
        let op = scope.new_operation("ImportEvent", |builder| {
            builder.add_input(writer);
            builder.add_input(event);
            ::std::result::Result::Ok(())
        })?;
        Ok(ImportEventInst { op })
    }
}
impl ImportEventInst {
    /// Returns the 'writer' Input of this 'ImportEvent' operation.
    pub fn writer(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'event' Input of this 'ImportEvent' operation.
    pub fn event(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<ImportEventInst> for crate::Operation {
    fn from(inst: ImportEventInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ImportEvent::new().build(writer, event, scope)`.
pub fn import_event<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    writer: O0,
    event: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ImportEvent::new().build(writer, event, scope)
}

/// Builder for the `InTopK` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct InTopK {
    k: ::std::option::Option<i64>,
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'InTopK' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct InTopKInst {
    /// An instance of a fully built InTopK Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl InTopK {
    /// Creates a new `InTopK`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `k` attribute.
    pub fn k<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.k = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `InTopK` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        predictions: O0,
        targets: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(predictions.into(), targets.into(), scope)
    }
    fn build_impl(
        &self,
        predictions: crate::Output,
        targets: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("InTopK", |nd| {
            nd.add_input(predictions);
            nd.add_input(targets);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.k {
                nd.set_attr_int("k", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'InTopK' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        predictions: crate::Output,
        targets: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<InTopKInst> {
        let op = scope.new_operation("InTopK", |builder| {
            builder.add_input(predictions);
            builder.add_input(targets);
            if let ::std::option::Option::Some(value) = &self.k {
                builder.set_attr_int("k", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(InTopKInst { op })
    }
}
impl InTopKInst {
    /// Returns the 'precision' Output of this 'InTopK' operation.
    pub fn precision(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'predictions' Input of this 'InTopK' operation.
    pub fn predictions(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'targets' Input of this 'InTopK' operation.
    pub fn targets(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<InTopKInst> for crate::Operation {
    fn from(inst: InTopKInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `InTopK::new().build(predictions, targets, scope)`.
pub fn in_top_k<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    predictions: O0,
    targets: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    InTopK::new().build(predictions, targets, scope)
}

/// Builder for the `InTopKV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct InTopKV2 {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'InTopKV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct InTopKV2Inst {
    /// An instance of a fully built InTopKV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl InTopKV2 {
    /// Creates a new `InTopKV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `InTopKV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        predictions: O0,
        targets: O1,
        k: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(predictions.into(), targets.into(), k.into(), scope)
    }
    fn build_impl(
        &self,
        predictions: crate::Output,
        targets: crate::Output,
        k: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("InTopKV2", |nd| {
            nd.add_input(predictions);
            nd.add_input(targets);
            nd.add_input(k);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'InTopKV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        predictions: crate::Output,
        targets: crate::Output,
        k: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<InTopKV2Inst> {
        let op = scope.new_operation("InTopKV2", |builder| {
            builder.add_input(predictions);
            builder.add_input(targets);
            builder.add_input(k);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(InTopKV2Inst { op })
    }
}
impl InTopKV2Inst {
    /// Returns the 'precision' Output of this 'InTopKV2' operation.
    pub fn precision(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'predictions' Input of this 'InTopKV2' operation.
    pub fn predictions(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'targets' Input of this 'InTopKV2' operation.
    pub fn targets(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'k' Input of this 'InTopKV2' operation.
    pub fn k(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<InTopKV2Inst> for crate::Operation {
    fn from(inst: InTopKV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `InTopKV2::new().build(predictions, targets, k, scope)`.
pub fn in_top_kv2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    predictions: O0,
    targets: O1,
    k: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    InTopKV2::new().build(predictions, targets, k, scope)
}

/// Builder for the `InfeedDequeue` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct InfeedDequeue {
    dtype: ::std::option::Option<crate::DataType>,
    shape: ::std::option::Option<crate::Shape>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'InfeedDequeue' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct InfeedDequeueInst {
    /// An instance of a fully built InfeedDequeue Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl InfeedDequeue {
    /// Creates a new `InfeedDequeue`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `dtype` attribute.
    pub fn dtype<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shape` attribute.
    pub fn shape<ArgType: ::std::convert::Into<crate::Shape>>(mut self, value: ArgType) -> Self {
        self.shape = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `InfeedDequeue` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("InfeedDequeue", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                nd.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shape {
                nd.set_attr_shape("shape", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'InfeedDequeue' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(&self, scope: &mut crate::Scope) -> crate::Result<InfeedDequeueInst> {
        let op = scope.new_operation("InfeedDequeue", |builder| {
            if let ::std::option::Option::Some(value) = &self.dtype {
                builder.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shape {
                builder.set_attr_shape("shape", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(InfeedDequeueInst { op })
    }
}
impl InfeedDequeueInst {
    /// Returns the 'output' Output of this 'InfeedDequeue' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
}
impl From<InfeedDequeueInst> for crate::Operation {
    fn from(inst: InfeedDequeueInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `InfeedDequeue::new().build(scope)`.
pub fn infeed_dequeue(scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
    InfeedDequeue::new().build(scope)
}

/// Builder for the `InfeedDequeueTuple` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct InfeedDequeueTuple {
    dtypes: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'InfeedDequeueTuple' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct InfeedDequeueTupleInst {
    /// An instance of a fully built InfeedDequeueTuple Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl InfeedDequeueTuple {
    /// Creates a new `InfeedDequeueTuple`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `dtypes` attribute.
    pub fn dtypes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.dtypes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shapes` attribute.
    pub fn shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `InfeedDequeueTuple` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("InfeedDequeueTuple", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.dtypes {
                nd.set_attr_type_list("dtypes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shapes {
                nd.set_attr_shape_list("shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'InfeedDequeueTuple' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        scope: &mut crate::Scope,
    ) -> crate::Result<InfeedDequeueTupleInst> {
        let op = scope.new_operation("InfeedDequeueTuple", |builder| {
            if let ::std::option::Option::Some(value) = &self.dtypes {
                builder.set_attr_type_list("dtypes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shapes {
                builder.set_attr_shape_list("shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(InfeedDequeueTupleInst { op })
    }
}
impl InfeedDequeueTupleInst {
    /// Returns the 'outputs' Output of this 'InfeedDequeueTuple' operation.
    pub fn outputs(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
}
impl From<InfeedDequeueTupleInst> for crate::Operation {
    fn from(inst: InfeedDequeueTupleInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `InfeedDequeueTuple::new().build(scope)`.
pub fn infeed_dequeue_tuple(scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
    InfeedDequeueTuple::new().build(scope)
}

/// Builder for the `InfeedEnqueue` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct InfeedEnqueue {
    dtype: ::std::option::Option<crate::DataType>,
    shape: ::std::option::Option<crate::Shape>,
    layout: ::std::option::Option<::std::vec::Vec<i64>>,
    device_ordinal: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'InfeedEnqueue' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct InfeedEnqueueInst {
    /// An instance of a fully built InfeedEnqueue Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl InfeedEnqueue {
    /// Creates a new `InfeedEnqueue`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `dtype` attribute.
    pub fn dtype<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shape` attribute.
    pub fn shape<ArgType: ::std::convert::Into<crate::Shape>>(mut self, value: ArgType) -> Self {
        self.shape = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `layout` attribute.
    pub fn layout<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.layout = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `device_ordinal` attribute.
    pub fn device_ordinal<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.device_ordinal = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `InfeedEnqueue` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("InfeedEnqueue", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                nd.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shape {
                nd.set_attr_shape("shape", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.layout {
                nd.set_attr_int_list("layout", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.device_ordinal {
                nd.set_attr_int("device_ordinal", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'InfeedEnqueue' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<InfeedEnqueueInst> {
        let op = scope.new_operation("InfeedEnqueue", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.dtype {
                builder.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shape {
                builder.set_attr_shape("shape", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.layout {
                builder.set_attr_int_list("layout", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.device_ordinal {
                builder.set_attr_int("device_ordinal", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(InfeedEnqueueInst { op })
    }
}
impl InfeedEnqueueInst {
    /// Returns the 'input' Input of this 'InfeedEnqueue' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<InfeedEnqueueInst> for crate::Operation {
    fn from(inst: InfeedEnqueueInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `InfeedEnqueue::new().build(input, scope)`.
pub fn infeed_enqueue<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    InfeedEnqueue::new().build(input, scope)
}

/// Builder for the `InfeedEnqueuePrelinearizedBuffer` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct InfeedEnqueuePrelinearizedBuffer {
    device_ordinal: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'InfeedEnqueuePrelinearizedBuffer' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct InfeedEnqueuePrelinearizedBufferInst {
    /// An instance of a fully built InfeedEnqueuePrelinearizedBuffer Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl InfeedEnqueuePrelinearizedBuffer {
    /// Creates a new `InfeedEnqueuePrelinearizedBuffer`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `device_ordinal` attribute.
    pub fn device_ordinal<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.device_ordinal = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `InfeedEnqueuePrelinearizedBuffer` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("InfeedEnqueuePrelinearizedBuffer", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.device_ordinal {
                nd.set_attr_int("device_ordinal", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'InfeedEnqueuePrelinearizedBuffer' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<InfeedEnqueuePrelinearizedBufferInst> {
        let op = scope.new_operation("InfeedEnqueuePrelinearizedBuffer", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.device_ordinal {
                builder.set_attr_int("device_ordinal", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(InfeedEnqueuePrelinearizedBufferInst { op })
    }
}
impl InfeedEnqueuePrelinearizedBufferInst {
    /// Returns the 'input' Input of this 'InfeedEnqueuePrelinearizedBuffer' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<InfeedEnqueuePrelinearizedBufferInst> for crate::Operation {
    fn from(inst: InfeedEnqueuePrelinearizedBufferInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `InfeedEnqueuePrelinearizedBuffer::new().build(input, scope)`.
pub fn infeed_enqueue_prelinearized_buffer<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    InfeedEnqueuePrelinearizedBuffer::new().build(input, scope)
}

/// Builder for the `InfeedEnqueueTuple` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct InfeedEnqueueTuple {
    dtypes: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    layouts: ::std::option::Option<::std::vec::Vec<i64>>,
    device_ordinal: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'InfeedEnqueueTuple' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct InfeedEnqueueTupleInst {
    /// An instance of a fully built InfeedEnqueueTuple Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl InfeedEnqueueTuple {
    /// Creates a new `InfeedEnqueueTuple`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `dtypes` attribute.
    pub fn dtypes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.dtypes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shapes` attribute.
    pub fn shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `layouts` attribute.
    pub fn layouts<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.layouts = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `device_ordinal` attribute.
    pub fn device_ordinal<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.device_ordinal = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `InfeedEnqueueTuple` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        inputs: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(inputs.into(), scope)
    }
    fn build_impl(
        &self,
        inputs: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("InfeedEnqueueTuple", |nd| {
            nd.add_input(inputs);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.dtypes {
                nd.set_attr_type_list("dtypes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shapes {
                nd.set_attr_shape_list("shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.layouts {
                nd.set_attr_int_list("layouts", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.device_ordinal {
                nd.set_attr_int("device_ordinal", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'InfeedEnqueueTuple' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        inputs: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<InfeedEnqueueTupleInst> {
        let op = scope.new_operation("InfeedEnqueueTuple", |builder| {
            builder.add_input(inputs);
            if let ::std::option::Option::Some(value) = &self.dtypes {
                builder.set_attr_type_list("dtypes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shapes {
                builder.set_attr_shape_list("shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.layouts {
                builder.set_attr_int_list("layouts", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.device_ordinal {
                builder.set_attr_int("device_ordinal", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(InfeedEnqueueTupleInst { op })
    }
}
impl InfeedEnqueueTupleInst {
    /// Returns the 'inputs' Input of this 'InfeedEnqueueTuple' operation.
    pub fn inputs(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<InfeedEnqueueTupleInst> for crate::Operation {
    fn from(inst: InfeedEnqueueTupleInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `InfeedEnqueueTuple::new().build(inputs, scope)`.
pub fn infeed_enqueue_tuple<O0: ::std::convert::Into<crate::Output>>(
    inputs: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    InfeedEnqueueTuple::new().build(inputs, scope)
}

/// Builder for the `InitializeTable` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct InitializeTable {
    Tkey: ::std::option::Option<crate::DataType>,
    Tval: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'InitializeTable' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct InitializeTableInst {
    /// An instance of a fully built InitializeTable Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl InitializeTable {
    /// Creates a new `InitializeTable`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `Tkey` attribute.
    pub fn Tkey<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Tkey = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tval` attribute.
    pub fn Tval<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Tval = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `InitializeTable` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        table_handle: O0,
        keys: O1,
        values: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(table_handle.into(), keys.into(), values.into(), scope)
    }
    fn build_impl(
        &self,
        table_handle: crate::Output,
        keys: crate::Output,
        values: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("InitializeTable", |nd| {
            nd.add_input(table_handle);
            nd.add_input(keys);
            nd.add_input(values);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.Tkey {
                nd.set_attr_type("Tkey", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tval {
                nd.set_attr_type("Tval", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'InitializeTable' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        table_handle: crate::Output,
        keys: crate::Output,
        values: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<InitializeTableInst> {
        let op = scope.new_operation("InitializeTable", |builder| {
            builder.add_input(table_handle);
            builder.add_input(keys);
            builder.add_input(values);
            if let ::std::option::Option::Some(value) = &self.Tkey {
                builder.set_attr_type("Tkey", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tval {
                builder.set_attr_type("Tval", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(InitializeTableInst { op })
    }
}
impl InitializeTableInst {
    /// Returns the 'table_handle' Input of this 'InitializeTable' operation.
    pub fn table_handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'keys' Input of this 'InitializeTable' operation.
    pub fn keys(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'values' Input of this 'InitializeTable' operation.
    pub fn values(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<InitializeTableInst> for crate::Operation {
    fn from(inst: InitializeTableInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `InitializeTable::new().build(table_handle, keys, values, scope)`.
pub fn initialize_table<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    table_handle: O0,
    keys: O1,
    values: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    InitializeTable::new().build(table_handle, keys, values, scope)
}

/// Builder for the `InitializeTableFromDataset` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct InitializeTableFromDataset {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'InitializeTableFromDataset' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct InitializeTableFromDatasetInst {
    /// An instance of a fully built InitializeTableFromDataset Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl InitializeTableFromDataset {
    /// Creates a new `InitializeTableFromDataset`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `InitializeTableFromDataset` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        table_handle: O0,
        dataset: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(table_handle.into(), dataset.into(), scope)
    }
    fn build_impl(
        &self,
        table_handle: crate::Output,
        dataset: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("InitializeTableFromDataset", |nd| {
            nd.add_input(table_handle);
            nd.add_input(dataset);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'InitializeTableFromDataset' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        table_handle: crate::Output,
        dataset: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<InitializeTableFromDatasetInst> {
        let op = scope.new_operation("InitializeTableFromDataset", |builder| {
            builder.add_input(table_handle);
            builder.add_input(dataset);
            ::std::result::Result::Ok(())
        })?;
        Ok(InitializeTableFromDatasetInst { op })
    }
}
impl InitializeTableFromDatasetInst {
    /// Returns the 'table_handle' Input of this 'InitializeTableFromDataset' operation.
    pub fn table_handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'dataset' Input of this 'InitializeTableFromDataset' operation.
    pub fn dataset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<InitializeTableFromDatasetInst> for crate::Operation {
    fn from(inst: InitializeTableFromDatasetInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `InitializeTableFromDataset::new().build(table_handle, dataset, scope)`.
pub fn initialize_table_from_dataset<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    table_handle: O0,
    dataset: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    InitializeTableFromDataset::new().build(table_handle, dataset, scope)
}

/// Builder for the `InitializeTableFromTextFile` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct InitializeTableFromTextFile {
    key_index: ::std::option::Option<i64>,
    value_index: ::std::option::Option<i64>,
    vocab_size: ::std::option::Option<i64>,
    delimiter: ::std::option::Option<::std::string::String>,
    offset: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'InitializeTableFromTextFile' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct InitializeTableFromTextFileInst {
    /// An instance of a fully built InitializeTableFromTextFile Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl InitializeTableFromTextFile {
    /// Creates a new `InitializeTableFromTextFile`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `key_index` attribute.
    pub fn key_index<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.key_index = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `value_index` attribute.
    pub fn value_index<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.value_index = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `vocab_size` attribute.
    pub fn vocab_size<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.vocab_size = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `delimiter` attribute.
    pub fn delimiter<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.delimiter = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `offset` attribute.
    pub fn offset<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.offset = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `InitializeTableFromTextFile` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        table_handle: O0,
        filename: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(table_handle.into(), filename.into(), scope)
    }
    fn build_impl(
        &self,
        table_handle: crate::Output,
        filename: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("InitializeTableFromTextFile", |nd| {
            nd.add_input(table_handle);
            nd.add_input(filename);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.key_index {
                nd.set_attr_int("key_index", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.value_index {
                nd.set_attr_int("value_index", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.vocab_size {
                nd.set_attr_int("vocab_size", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.delimiter {
                nd.set_attr_string("delimiter", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.offset {
                nd.set_attr_int("offset", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'InitializeTableFromTextFile' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        table_handle: crate::Output,
        filename: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<InitializeTableFromTextFileInst> {
        let op = scope.new_operation("InitializeTableFromTextFile", |builder| {
            builder.add_input(table_handle);
            builder.add_input(filename);
            if let ::std::option::Option::Some(value) = &self.key_index {
                builder.set_attr_int("key_index", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.value_index {
                builder.set_attr_int("value_index", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.vocab_size {
                builder.set_attr_int("vocab_size", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.delimiter {
                builder.set_attr_string("delimiter", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.offset {
                builder.set_attr_int("offset", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(InitializeTableFromTextFileInst { op })
    }
}
impl InitializeTableFromTextFileInst {
    /// Returns the 'table_handle' Input of this 'InitializeTableFromTextFile' operation.
    pub fn table_handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'filename' Input of this 'InitializeTableFromTextFile' operation.
    pub fn filename(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<InitializeTableFromTextFileInst> for crate::Operation {
    fn from(inst: InitializeTableFromTextFileInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `InitializeTableFromTextFile::new().build(table_handle, filename, scope)`.
pub fn initialize_table_from_text_file<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    table_handle: O0,
    filename: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    InitializeTableFromTextFile::new().build(table_handle, filename, scope)
}

/// Builder for the `InitializeTableFromTextFileV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct InitializeTableFromTextFileV2 {
    key_index: ::std::option::Option<i64>,
    value_index: ::std::option::Option<i64>,
    vocab_size: ::std::option::Option<i64>,
    delimiter: ::std::option::Option<::std::string::String>,
    offset: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'InitializeTableFromTextFileV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct InitializeTableFromTextFileV2Inst {
    /// An instance of a fully built InitializeTableFromTextFileV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl InitializeTableFromTextFileV2 {
    /// Creates a new `InitializeTableFromTextFileV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `key_index` attribute.
    pub fn key_index<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.key_index = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `value_index` attribute.
    pub fn value_index<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.value_index = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `vocab_size` attribute.
    pub fn vocab_size<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.vocab_size = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `delimiter` attribute.
    pub fn delimiter<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.delimiter = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `offset` attribute.
    pub fn offset<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.offset = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `InitializeTableFromTextFileV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        table_handle: O0,
        filename: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(table_handle.into(), filename.into(), scope)
    }
    fn build_impl(
        &self,
        table_handle: crate::Output,
        filename: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("InitializeTableFromTextFileV2", |nd| {
            nd.add_input(table_handle);
            nd.add_input(filename);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.key_index {
                nd.set_attr_int("key_index", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.value_index {
                nd.set_attr_int("value_index", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.vocab_size {
                nd.set_attr_int("vocab_size", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.delimiter {
                nd.set_attr_string("delimiter", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.offset {
                nd.set_attr_int("offset", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'InitializeTableFromTextFileV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        table_handle: crate::Output,
        filename: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<InitializeTableFromTextFileV2Inst> {
        let op = scope.new_operation("InitializeTableFromTextFileV2", |builder| {
            builder.add_input(table_handle);
            builder.add_input(filename);
            if let ::std::option::Option::Some(value) = &self.key_index {
                builder.set_attr_int("key_index", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.value_index {
                builder.set_attr_int("value_index", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.vocab_size {
                builder.set_attr_int("vocab_size", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.delimiter {
                builder.set_attr_string("delimiter", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.offset {
                builder.set_attr_int("offset", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(InitializeTableFromTextFileV2Inst { op })
    }
}
impl InitializeTableFromTextFileV2Inst {
    /// Returns the 'table_handle' Input of this 'InitializeTableFromTextFileV2' operation.
    pub fn table_handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'filename' Input of this 'InitializeTableFromTextFileV2' operation.
    pub fn filename(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<InitializeTableFromTextFileV2Inst> for crate::Operation {
    fn from(inst: InitializeTableFromTextFileV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `InitializeTableFromTextFileV2::new().build(table_handle, filename, scope)`.
pub fn initialize_table_from_text_file_v2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    table_handle: O0,
    filename: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    InitializeTableFromTextFileV2::new().build(table_handle, filename, scope)
}

/// Builder for the `InitializeTableV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct InitializeTableV2 {
    Tkey: ::std::option::Option<crate::DataType>,
    Tval: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'InitializeTableV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct InitializeTableV2Inst {
    /// An instance of a fully built InitializeTableV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl InitializeTableV2 {
    /// Creates a new `InitializeTableV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `Tkey` attribute.
    pub fn Tkey<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Tkey = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tval` attribute.
    pub fn Tval<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Tval = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `InitializeTableV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        table_handle: O0,
        keys: O1,
        values: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(table_handle.into(), keys.into(), values.into(), scope)
    }
    fn build_impl(
        &self,
        table_handle: crate::Output,
        keys: crate::Output,
        values: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("InitializeTableV2", |nd| {
            nd.add_input(table_handle);
            nd.add_input(keys);
            nd.add_input(values);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.Tkey {
                nd.set_attr_type("Tkey", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tval {
                nd.set_attr_type("Tval", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'InitializeTableV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        table_handle: crate::Output,
        keys: crate::Output,
        values: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<InitializeTableV2Inst> {
        let op = scope.new_operation("InitializeTableV2", |builder| {
            builder.add_input(table_handle);
            builder.add_input(keys);
            builder.add_input(values);
            if let ::std::option::Option::Some(value) = &self.Tkey {
                builder.set_attr_type("Tkey", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tval {
                builder.set_attr_type("Tval", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(InitializeTableV2Inst { op })
    }
}
impl InitializeTableV2Inst {
    /// Returns the 'table_handle' Input of this 'InitializeTableV2' operation.
    pub fn table_handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'keys' Input of this 'InitializeTableV2' operation.
    pub fn keys(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'values' Input of this 'InitializeTableV2' operation.
    pub fn values(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<InitializeTableV2Inst> for crate::Operation {
    fn from(inst: InitializeTableV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `InitializeTableV2::new().build(table_handle, keys, values, scope)`.
pub fn initialize_table_v2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    table_handle: O0,
    keys: O1,
    values: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    InitializeTableV2::new().build(table_handle, keys, values, scope)
}

/// Builder for the `InplaceAdd` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct InplaceAdd {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'InplaceAdd' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct InplaceAddInst {
    /// An instance of a fully built InplaceAdd Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl InplaceAdd {
    /// Creates a new `InplaceAdd`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `InplaceAdd` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        x: O0,
        i: O1,
        v: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), i.into(), v.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        i: crate::Output,
        v: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("InplaceAdd", |nd| {
            nd.add_input(x);
            nd.add_input(i);
            nd.add_input(v);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'InplaceAdd' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        i: crate::Output,
        v: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<InplaceAddInst> {
        let op = scope.new_operation("InplaceAdd", |builder| {
            builder.add_input(x);
            builder.add_input(i);
            builder.add_input(v);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(InplaceAddInst { op })
    }
}
impl InplaceAddInst {
    /// Returns the 'y' Output of this 'InplaceAdd' operation.
    pub fn y(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'InplaceAdd' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'i' Input of this 'InplaceAdd' operation.
    pub fn i(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'v' Input of this 'InplaceAdd' operation.
    pub fn v(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<InplaceAddInst> for crate::Operation {
    fn from(inst: InplaceAddInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `InplaceAdd::new().build(x, i, v, scope)`.
pub fn inplace_add<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    x: O0,
    i: O1,
    v: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    InplaceAdd::new().build(x, i, v, scope)
}

/// Builder for the `InplaceSub` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct InplaceSub {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'InplaceSub' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct InplaceSubInst {
    /// An instance of a fully built InplaceSub Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl InplaceSub {
    /// Creates a new `InplaceSub`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `InplaceSub` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        x: O0,
        i: O1,
        v: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), i.into(), v.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        i: crate::Output,
        v: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("InplaceSub", |nd| {
            nd.add_input(x);
            nd.add_input(i);
            nd.add_input(v);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'InplaceSub' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        i: crate::Output,
        v: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<InplaceSubInst> {
        let op = scope.new_operation("InplaceSub", |builder| {
            builder.add_input(x);
            builder.add_input(i);
            builder.add_input(v);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(InplaceSubInst { op })
    }
}
impl InplaceSubInst {
    /// Returns the 'y' Output of this 'InplaceSub' operation.
    pub fn y(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'InplaceSub' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'i' Input of this 'InplaceSub' operation.
    pub fn i(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'v' Input of this 'InplaceSub' operation.
    pub fn v(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<InplaceSubInst> for crate::Operation {
    fn from(inst: InplaceSubInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `InplaceSub::new().build(x, i, v, scope)`.
pub fn inplace_sub<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    x: O0,
    i: O1,
    v: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    InplaceSub::new().build(x, i, v, scope)
}

/// Builder for the `InplaceUpdate` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct InplaceUpdate {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'InplaceUpdate' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct InplaceUpdateInst {
    /// An instance of a fully built InplaceUpdate Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl InplaceUpdate {
    /// Creates a new `InplaceUpdate`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `InplaceUpdate` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        x: O0,
        i: O1,
        v: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), i.into(), v.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        i: crate::Output,
        v: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("InplaceUpdate", |nd| {
            nd.add_input(x);
            nd.add_input(i);
            nd.add_input(v);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'InplaceUpdate' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        i: crate::Output,
        v: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<InplaceUpdateInst> {
        let op = scope.new_operation("InplaceUpdate", |builder| {
            builder.add_input(x);
            builder.add_input(i);
            builder.add_input(v);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(InplaceUpdateInst { op })
    }
}
impl InplaceUpdateInst {
    /// Returns the 'y' Output of this 'InplaceUpdate' operation.
    pub fn y(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'InplaceUpdate' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'i' Input of this 'InplaceUpdate' operation.
    pub fn i(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'v' Input of this 'InplaceUpdate' operation.
    pub fn v(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<InplaceUpdateInst> for crate::Operation {
    fn from(inst: InplaceUpdateInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `InplaceUpdate::new().build(x, i, v, scope)`.
pub fn inplace_update<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    x: O0,
    i: O1,
    v: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    InplaceUpdate::new().build(x, i, v, scope)
}

/// Builder for the `InterleaveDataset` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct InterleaveDataset {
    f: ::std::option::Option<::std::string::String>,
    Targuments: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    metadata: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'InterleaveDataset' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct InterleaveDatasetInst {
    /// An instance of a fully built InterleaveDataset Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl InterleaveDataset {
    /// Creates a new `InterleaveDataset`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `f` attribute.
    pub fn f<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.f = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Targuments` attribute.
    pub fn Targuments<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Targuments = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `metadata` attribute.
    pub fn metadata<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.metadata = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `InterleaveDataset` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input_dataset: O0,
        other_arguments: O1,
        cycle_length: O2,
        block_length: O3,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            input_dataset.into(),
            other_arguments.into(),
            cycle_length.into(),
            block_length.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        input_dataset: crate::Output,
        other_arguments: crate::Output,
        cycle_length: crate::Output,
        block_length: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("InterleaveDataset", |nd| {
            nd.add_input(input_dataset);
            nd.add_input(other_arguments);
            nd.add_input(cycle_length);
            nd.add_input(block_length);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.f {
                nd.set_attr_string("f", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Targuments {
                nd.set_attr_type_list("Targuments", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.metadata {
                nd.set_attr_string("metadata", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'InterleaveDataset' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_dataset: crate::Output,
        other_arguments: crate::Output,
        cycle_length: crate::Output,
        block_length: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<InterleaveDatasetInst> {
        let op = scope.new_operation("InterleaveDataset", |builder| {
            builder.add_input(input_dataset);
            builder.add_input(other_arguments);
            builder.add_input(cycle_length);
            builder.add_input(block_length);
            if let ::std::option::Option::Some(value) = &self.f {
                builder.set_attr_string("f", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Targuments {
                builder.set_attr_type_list("Targuments", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.metadata {
                builder.set_attr_string("metadata", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(InterleaveDatasetInst { op })
    }
}
impl InterleaveDatasetInst {
    /// Returns the 'handle' Output of this 'InterleaveDataset' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_dataset' Input of this 'InterleaveDataset' operation.
    pub fn input_dataset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'other_arguments' Input of this 'InterleaveDataset' operation.
    pub fn other_arguments(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'cycle_length' Input of this 'InterleaveDataset' operation.
    pub fn cycle_length(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'block_length' Input of this 'InterleaveDataset' operation.
    pub fn block_length(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
}
impl From<InterleaveDatasetInst> for crate::Operation {
    fn from(inst: InterleaveDatasetInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `InterleaveDataset::new().build(input_dataset, other_arguments, cycle_length, block_length, scope)`.
pub fn interleave_dataset<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
>(
    input_dataset: O0,
    other_arguments: O1,
    cycle_length: O2,
    block_length: O3,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    InterleaveDataset::new().build(
        input_dataset,
        other_arguments,
        cycle_length,
        block_length,
        scope,
    )
}

/// Builder for the `Inv` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Inv {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Inv' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct InvInst {
    /// An instance of a fully built Inv Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Inv {
    /// Creates a new `Inv`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Inv` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        x: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Inv", |nd| {
            nd.add_input(x);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Inv' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<InvInst> {
        let op = scope.new_operation("Inv", |builder| {
            builder.add_input(x);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(InvInst { op })
    }
}
impl InvInst {
    /// Returns the 'y' Output of this 'Inv' operation.
    pub fn y(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'Inv' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<InvInst> for crate::Operation {
    fn from(inst: InvInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Inv::new().build(x, scope)`.
pub fn inv<O0: ::std::convert::Into<crate::Output>>(
    x: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Inv::new().build(x, scope)
}

/// Builder for the `InvGrad` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct InvGrad {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'InvGrad' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct InvGradInst {
    /// An instance of a fully built InvGrad Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl InvGrad {
    /// Creates a new `InvGrad`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `InvGrad` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        y: O0,
        dy: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(y.into(), dy.into(), scope)
    }
    fn build_impl(
        &self,
        y: crate::Output,
        dy: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("InvGrad", |nd| {
            nd.add_input(y);
            nd.add_input(dy);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'InvGrad' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        y: crate::Output,
        dy: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<InvGradInst> {
        let op = scope.new_operation("InvGrad", |builder| {
            builder.add_input(y);
            builder.add_input(dy);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(InvGradInst { op })
    }
}
impl InvGradInst {
    /// Returns the 'z' Output of this 'InvGrad' operation.
    pub fn z(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'y' Input of this 'InvGrad' operation.
    pub fn y(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'dy' Input of this 'InvGrad' operation.
    pub fn dy(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<InvGradInst> for crate::Operation {
    fn from(inst: InvGradInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `InvGrad::new().build(y, dy, scope)`.
pub fn inv_grad<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    y: O0,
    dy: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    InvGrad::new().build(y, dy, scope)
}

/// Builder for the `Invert` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Invert {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Invert' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct InvertInst {
    /// An instance of a fully built Invert Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Invert {
    /// Creates a new `Invert`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Invert` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        x: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Invert", |nd| {
            nd.add_input(x);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Invert' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<InvertInst> {
        let op = scope.new_operation("Invert", |builder| {
            builder.add_input(x);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(InvertInst { op })
    }
}
impl InvertInst {
    /// Returns the 'y' Output of this 'Invert' operation.
    pub fn y(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'Invert' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<InvertInst> for crate::Operation {
    fn from(inst: InvertInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Invert::new().build(x, scope)`.
pub fn invert<O0: ::std::convert::Into<crate::Output>>(
    x: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Invert::new().build(x, scope)
}

/// Builder for the `InvertPermutation` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct InvertPermutation {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'InvertPermutation' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct InvertPermutationInst {
    /// An instance of a fully built InvertPermutation Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl InvertPermutation {
    /// Creates a new `InvertPermutation`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `InvertPermutation` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        x: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("InvertPermutation", |nd| {
            nd.add_input(x);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'InvertPermutation' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<InvertPermutationInst> {
        let op = scope.new_operation("InvertPermutation", |builder| {
            builder.add_input(x);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(InvertPermutationInst { op })
    }
}
impl InvertPermutationInst {
    /// Returns the 'y' Output of this 'InvertPermutation' operation.
    pub fn y(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'InvertPermutation' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<InvertPermutationInst> for crate::Operation {
    fn from(inst: InvertPermutationInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `InvertPermutation::new().build(x, scope)`.
pub fn invert_permutation<O0: ::std::convert::Into<crate::Output>>(
    x: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    InvertPermutation::new().build(x, scope)
}

/// Builder for the `IsBoostedTreesEnsembleInitialized` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct IsBoostedTreesEnsembleInitialized {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'IsBoostedTreesEnsembleInitialized' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct IsBoostedTreesEnsembleInitializedInst {
    /// An instance of a fully built IsBoostedTreesEnsembleInitialized Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl IsBoostedTreesEnsembleInitialized {
    /// Creates a new `IsBoostedTreesEnsembleInitialized`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `IsBoostedTreesEnsembleInitialized` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        tree_ensemble_handle: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(tree_ensemble_handle.into(), scope)
    }
    fn build_impl(
        &self,
        tree_ensemble_handle: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("IsBoostedTreesEnsembleInitialized", |nd| {
            nd.add_input(tree_ensemble_handle);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'IsBoostedTreesEnsembleInitialized' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        tree_ensemble_handle: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<IsBoostedTreesEnsembleInitializedInst> {
        let op = scope.new_operation("IsBoostedTreesEnsembleInitialized", |builder| {
            builder.add_input(tree_ensemble_handle);
            ::std::result::Result::Ok(())
        })?;
        Ok(IsBoostedTreesEnsembleInitializedInst { op })
    }
}
impl IsBoostedTreesEnsembleInitializedInst {
    /// Returns the 'is_initialized' Output of this 'IsBoostedTreesEnsembleInitialized' operation.
    pub fn is_initialized(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'tree_ensemble_handle' Input of this 'IsBoostedTreesEnsembleInitialized' operation.
    pub fn tree_ensemble_handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<IsBoostedTreesEnsembleInitializedInst> for crate::Operation {
    fn from(inst: IsBoostedTreesEnsembleInitializedInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `IsBoostedTreesEnsembleInitialized::new().build(tree_ensemble_handle, scope)`.
pub fn is_boosted_trees_ensemble_initialized<O0: ::std::convert::Into<crate::Output>>(
    tree_ensemble_handle: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    IsBoostedTreesEnsembleInitialized::new().build(tree_ensemble_handle, scope)
}

/// Builder for the `IsBoostedTreesQuantileStreamResourceInitialized` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct IsBoostedTreesQuantileStreamResourceInitialized {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'IsBoostedTreesQuantileStreamResourceInitialized' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct IsBoostedTreesQuantileStreamResourceInitializedInst {
    /// An instance of a fully built IsBoostedTreesQuantileStreamResourceInitialized Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl IsBoostedTreesQuantileStreamResourceInitialized {
    /// Creates a new `IsBoostedTreesQuantileStreamResourceInitialized`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `IsBoostedTreesQuantileStreamResourceInitialized` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        quantile_stream_resource_handle: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(quantile_stream_resource_handle.into(), scope)
    }
    fn build_impl(
        &self,
        quantile_stream_resource_handle: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("IsBoostedTreesQuantileStreamResourceInitialized", |nd| {
            nd.add_input(quantile_stream_resource_handle);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'IsBoostedTreesQuantileStreamResourceInitialized' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        quantile_stream_resource_handle: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<IsBoostedTreesQuantileStreamResourceInitializedInst> {
        let op = scope.new_operation(
            "IsBoostedTreesQuantileStreamResourceInitialized",
            |builder| {
                builder.add_input(quantile_stream_resource_handle);
                ::std::result::Result::Ok(())
            },
        )?;
        Ok(IsBoostedTreesQuantileStreamResourceInitializedInst { op })
    }
}
impl IsBoostedTreesQuantileStreamResourceInitializedInst {
    /// Returns the 'is_initialized' Output of this 'IsBoostedTreesQuantileStreamResourceInitialized' operation.
    pub fn is_initialized(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'quantile_stream_resource_handle' Input of this 'IsBoostedTreesQuantileStreamResourceInitialized' operation.
    pub fn quantile_stream_resource_handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<IsBoostedTreesQuantileStreamResourceInitializedInst> for crate::Operation {
    fn from(inst: IsBoostedTreesQuantileStreamResourceInitializedInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `IsBoostedTreesQuantileStreamResourceInitialized::new().build(quantile_stream_resource_handle, scope)`.
pub fn is_boosted_trees_quantile_stream_resource_initialized<
    O0: ::std::convert::Into<crate::Output>,
>(
    quantile_stream_resource_handle: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    IsBoostedTreesQuantileStreamResourceInitialized::new()
        .build(quantile_stream_resource_handle, scope)
}

/// Builder for the `IsFinite` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct IsFinite {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'IsFinite' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct IsFiniteInst {
    /// An instance of a fully built IsFinite Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl IsFinite {
    /// Creates a new `IsFinite`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `IsFinite` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        x: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("IsFinite", |nd| {
            nd.add_input(x);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'IsFinite' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<IsFiniteInst> {
        let op = scope.new_operation("IsFinite", |builder| {
            builder.add_input(x);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(IsFiniteInst { op })
    }
}
impl IsFiniteInst {
    /// Returns the 'y' Output of this 'IsFinite' operation.
    pub fn y(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'IsFinite' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<IsFiniteInst> for crate::Operation {
    fn from(inst: IsFiniteInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `IsFinite::new().build(x, scope)`.
pub fn is_finite<O0: ::std::convert::Into<crate::Output>>(
    x: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    IsFinite::new().build(x, scope)
}

/// Builder for the `IsInf` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct IsInf {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'IsInf' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct IsInfInst {
    /// An instance of a fully built IsInf Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl IsInf {
    /// Creates a new `IsInf`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `IsInf` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        x: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("IsInf", |nd| {
            nd.add_input(x);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'IsInf' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<IsInfInst> {
        let op = scope.new_operation("IsInf", |builder| {
            builder.add_input(x);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(IsInfInst { op })
    }
}
impl IsInfInst {
    /// Returns the 'y' Output of this 'IsInf' operation.
    pub fn y(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'IsInf' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<IsInfInst> for crate::Operation {
    fn from(inst: IsInfInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `IsInf::new().build(x, scope)`.
pub fn is_inf<O0: ::std::convert::Into<crate::Output>>(
    x: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    IsInf::new().build(x, scope)
}

/// Builder for the `IsNan` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct IsNan {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'IsNan' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct IsNanInst {
    /// An instance of a fully built IsNan Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl IsNan {
    /// Creates a new `IsNan`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `IsNan` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        x: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("IsNan", |nd| {
            nd.add_input(x);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'IsNan' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<IsNanInst> {
        let op = scope.new_operation("IsNan", |builder| {
            builder.add_input(x);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(IsNanInst { op })
    }
}
impl IsNanInst {
    /// Returns the 'y' Output of this 'IsNan' operation.
    pub fn y(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'IsNan' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<IsNanInst> for crate::Operation {
    fn from(inst: IsNanInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `IsNan::new().build(x, scope)`.
pub fn is_nan<O0: ::std::convert::Into<crate::Output>>(
    x: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    IsNan::new().build(x, scope)
}

/// Builder for the `IsTPUEmbeddingInitialized` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct IsTPUEmbeddingInitialized {
    config: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'IsTPUEmbeddingInitialized' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct IsTPUEmbeddingInitializedInst {
    /// An instance of a fully built IsTPUEmbeddingInitialized Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl IsTPUEmbeddingInitialized {
    /// Creates a new `IsTPUEmbeddingInitialized`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `config` attribute.
    pub fn config<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.config = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `IsTPUEmbeddingInitialized` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("IsTPUEmbeddingInitialized", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.config {
                nd.set_attr_string("config", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'IsTPUEmbeddingInitialized' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        scope: &mut crate::Scope,
    ) -> crate::Result<IsTPUEmbeddingInitializedInst> {
        let op = scope.new_operation("IsTPUEmbeddingInitialized", |builder| {
            if let ::std::option::Option::Some(value) = &self.config {
                builder.set_attr_string("config", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(IsTPUEmbeddingInitializedInst { op })
    }
}
impl IsTPUEmbeddingInitializedInst {
    /// Returns the 'is_tpu_embedding_initialized' Output of this 'IsTPUEmbeddingInitialized' operation.
    pub fn is_tpu_embedding_initialized(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
}
impl From<IsTPUEmbeddingInitializedInst> for crate::Operation {
    fn from(inst: IsTPUEmbeddingInitializedInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `IsTPUEmbeddingInitialized::new().build(scope)`.
pub fn is_tpuembedding_initialized(scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
    IsTPUEmbeddingInitialized::new().build(scope)
}

/// Builder for the `IsVariableInitialized` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct IsVariableInitialized {
    dtype: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'IsVariableInitialized' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct IsVariableInitializedInst {
    /// An instance of a fully built IsVariableInitialized Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl IsVariableInitialized {
    /// Creates a new `IsVariableInitialized`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `dtype` attribute.
    pub fn dtype<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `IsVariableInitialized` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        ref_: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(ref_.into(), scope)
    }
    fn build_impl(
        &self,
        ref_: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("IsVariableInitialized", |nd| {
            nd.add_input(ref_);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                nd.set_attr_type("dtype", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'IsVariableInitialized' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        ref_: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<IsVariableInitializedInst> {
        let op = scope.new_operation("IsVariableInitialized", |builder| {
            builder.add_input(ref_);
            if let ::std::option::Option::Some(value) = &self.dtype {
                builder.set_attr_type("dtype", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(IsVariableInitializedInst { op })
    }
}
impl IsVariableInitializedInst {
    /// Returns the 'is_initialized' Output of this 'IsVariableInitialized' operation.
    pub fn is_initialized(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'ref_' Input of this 'IsVariableInitialized' operation.
    pub fn ref_(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<IsVariableInitializedInst> for crate::Operation {
    fn from(inst: IsVariableInitializedInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `IsVariableInitialized::new().build(ref_, scope)`.
pub fn is_variable_initialized<O0: ::std::convert::Into<crate::Output>>(
    ref_: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    IsVariableInitialized::new().build(ref_, scope)
}

/// Builder for the `IsotonicRegression` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct IsotonicRegression {
    T: ::std::option::Option<crate::DataType>,
    output_dtype: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'IsotonicRegression' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct IsotonicRegressionInst {
    /// An instance of a fully built IsotonicRegression Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl IsotonicRegression {
    /// Creates a new `IsotonicRegression`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_dtype` attribute.
    pub fn output_dtype<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `IsotonicRegression` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("IsotonicRegression", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_dtype {
                nd.set_attr_type("output_dtype", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'IsotonicRegression' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<IsotonicRegressionInst> {
        let op = scope.new_operation("IsotonicRegression", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_dtype {
                builder.set_attr_type("output_dtype", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(IsotonicRegressionInst { op })
    }
}
impl IsotonicRegressionInst {
    /// Returns the 'output' Output of this 'IsotonicRegression' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'segments' Output of this 'IsotonicRegression' operation.
    pub fn segments(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'input' Input of this 'IsotonicRegression' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<IsotonicRegressionInst> for crate::Operation {
    fn from(inst: IsotonicRegressionInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `IsotonicRegression::new().build(input, scope)`.
pub fn isotonic_regression<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    IsotonicRegression::new().build(input, scope)
}

/// Builder for the `Iterator` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Iterator {
    shared_name: ::std::option::Option<::std::string::String>,
    container: ::std::option::Option<::std::string::String>,
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Iterator' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct IteratorInst {
    /// An instance of a fully built Iterator Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Iterator {
    /// Creates a new `Iterator`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `shared_name` attribute.
    pub fn shared_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.shared_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `container` attribute.
    pub fn container<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.container = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Iterator` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("Iterator", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                nd.set_attr_string("shared_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.container {
                nd.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Iterator' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(&self, scope: &mut crate::Scope) -> crate::Result<IteratorInst> {
        let op = scope.new_operation("Iterator", |builder| {
            if let ::std::option::Option::Some(value) = &self.shared_name {
                builder.set_attr_string("shared_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.container {
                builder.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(IteratorInst { op })
    }
}
impl IteratorInst {
    /// Returns the 'handle' Output of this 'Iterator' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
}
impl From<IteratorInst> for crate::Operation {
    fn from(inst: IteratorInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Iterator::new().build(scope)`.
pub fn iterator(scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
    Iterator::new().build(scope)
}

/// Builder for the `IteratorFromStringHandle` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct IteratorFromStringHandle {
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'IteratorFromStringHandle' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct IteratorFromStringHandleInst {
    /// An instance of a fully built IteratorFromStringHandle Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl IteratorFromStringHandle {
    /// Creates a new `IteratorFromStringHandle`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `IteratorFromStringHandle` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        string_handle: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(string_handle.into(), scope)
    }
    fn build_impl(
        &self,
        string_handle: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("IteratorFromStringHandle", |nd| {
            nd.add_input(string_handle);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'IteratorFromStringHandle' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        string_handle: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<IteratorFromStringHandleInst> {
        let op = scope.new_operation("IteratorFromStringHandle", |builder| {
            builder.add_input(string_handle);
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(IteratorFromStringHandleInst { op })
    }
}
impl IteratorFromStringHandleInst {
    /// Returns the 'resource_handle' Output of this 'IteratorFromStringHandle' operation.
    pub fn resource_handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'string_handle' Input of this 'IteratorFromStringHandle' operation.
    pub fn string_handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<IteratorFromStringHandleInst> for crate::Operation {
    fn from(inst: IteratorFromStringHandleInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `IteratorFromStringHandle::new().build(string_handle, scope)`.
pub fn iterator_from_string_handle<O0: ::std::convert::Into<crate::Output>>(
    string_handle: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    IteratorFromStringHandle::new().build(string_handle, scope)
}

/// Builder for the `IteratorFromStringHandleV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct IteratorFromStringHandleV2 {
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'IteratorFromStringHandleV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct IteratorFromStringHandleV2Inst {
    /// An instance of a fully built IteratorFromStringHandleV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl IteratorFromStringHandleV2 {
    /// Creates a new `IteratorFromStringHandleV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `IteratorFromStringHandleV2` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        string_handle: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(string_handle.into(), scope)
    }
    fn build_impl(
        &self,
        string_handle: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("IteratorFromStringHandleV2", |nd| {
            nd.add_input(string_handle);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'IteratorFromStringHandleV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        string_handle: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<IteratorFromStringHandleV2Inst> {
        let op = scope.new_operation("IteratorFromStringHandleV2", |builder| {
            builder.add_input(string_handle);
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(IteratorFromStringHandleV2Inst { op })
    }
}
impl IteratorFromStringHandleV2Inst {
    /// Returns the 'resource_handle' Output of this 'IteratorFromStringHandleV2' operation.
    pub fn resource_handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'string_handle' Input of this 'IteratorFromStringHandleV2' operation.
    pub fn string_handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<IteratorFromStringHandleV2Inst> for crate::Operation {
    fn from(inst: IteratorFromStringHandleV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `IteratorFromStringHandleV2::new().build(string_handle, scope)`.
pub fn iterator_from_string_handle_v2<O0: ::std::convert::Into<crate::Output>>(
    string_handle: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    IteratorFromStringHandleV2::new().build(string_handle, scope)
}

/// Builder for the `IteratorGetDevice` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct IteratorGetDevice {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'IteratorGetDevice' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct IteratorGetDeviceInst {
    /// An instance of a fully built IteratorGetDevice Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl IteratorGetDevice {
    /// Creates a new `IteratorGetDevice`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `IteratorGetDevice` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        resource: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(resource.into(), scope)
    }
    fn build_impl(
        &self,
        resource: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("IteratorGetDevice", |nd| {
            nd.add_input(resource);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'IteratorGetDevice' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        resource: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<IteratorGetDeviceInst> {
        let op = scope.new_operation("IteratorGetDevice", |builder| {
            builder.add_input(resource);
            ::std::result::Result::Ok(())
        })?;
        Ok(IteratorGetDeviceInst { op })
    }
}
impl IteratorGetDeviceInst {
    /// Returns the 'device' Output of this 'IteratorGetDevice' operation.
    pub fn device(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'resource' Input of this 'IteratorGetDevice' operation.
    pub fn resource(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<IteratorGetDeviceInst> for crate::Operation {
    fn from(inst: IteratorGetDeviceInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `IteratorGetDevice::new().build(resource, scope)`.
pub fn iterator_get_device<O0: ::std::convert::Into<crate::Output>>(
    resource: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    IteratorGetDevice::new().build(resource, scope)
}

/// Builder for the `IteratorGetNext` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct IteratorGetNext {
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'IteratorGetNext' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct IteratorGetNextInst {
    /// An instance of a fully built IteratorGetNext Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl IteratorGetNext {
    /// Creates a new `IteratorGetNext`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `IteratorGetNext` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        iterator: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(iterator.into(), scope)
    }
    fn build_impl(
        &self,
        iterator: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("IteratorGetNext", |nd| {
            nd.add_input(iterator);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'IteratorGetNext' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        iterator: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<IteratorGetNextInst> {
        let op = scope.new_operation("IteratorGetNext", |builder| {
            builder.add_input(iterator);
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(IteratorGetNextInst { op })
    }
}
impl IteratorGetNextInst {
    /// Returns the 'components' Output of this 'IteratorGetNext' operation.
    pub fn components(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'iterator' Input of this 'IteratorGetNext' operation.
    pub fn iterator(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<IteratorGetNextInst> for crate::Operation {
    fn from(inst: IteratorGetNextInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `IteratorGetNext::new().build(iterator, scope)`.
pub fn iterator_get_next<O0: ::std::convert::Into<crate::Output>>(
    iterator: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    IteratorGetNext::new().build(iterator, scope)
}

/// Builder for the `IteratorGetNextAsOptional` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct IteratorGetNextAsOptional {
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'IteratorGetNextAsOptional' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct IteratorGetNextAsOptionalInst {
    /// An instance of a fully built IteratorGetNextAsOptional Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl IteratorGetNextAsOptional {
    /// Creates a new `IteratorGetNextAsOptional`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `IteratorGetNextAsOptional` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        iterator: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(iterator.into(), scope)
    }
    fn build_impl(
        &self,
        iterator: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("IteratorGetNextAsOptional", |nd| {
            nd.add_input(iterator);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'IteratorGetNextAsOptional' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        iterator: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<IteratorGetNextAsOptionalInst> {
        let op = scope.new_operation("IteratorGetNextAsOptional", |builder| {
            builder.add_input(iterator);
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(IteratorGetNextAsOptionalInst { op })
    }
}
impl IteratorGetNextAsOptionalInst {
    /// Returns the 'optional' Output of this 'IteratorGetNextAsOptional' operation.
    pub fn optional(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'iterator' Input of this 'IteratorGetNextAsOptional' operation.
    pub fn iterator(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<IteratorGetNextAsOptionalInst> for crate::Operation {
    fn from(inst: IteratorGetNextAsOptionalInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `IteratorGetNextAsOptional::new().build(iterator, scope)`.
pub fn iterator_get_next_as_optional<O0: ::std::convert::Into<crate::Output>>(
    iterator: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    IteratorGetNextAsOptional::new().build(iterator, scope)
}

/// Builder for the `IteratorGetNextSync` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct IteratorGetNextSync {
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'IteratorGetNextSync' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct IteratorGetNextSyncInst {
    /// An instance of a fully built IteratorGetNextSync Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl IteratorGetNextSync {
    /// Creates a new `IteratorGetNextSync`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `IteratorGetNextSync` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        iterator: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(iterator.into(), scope)
    }
    fn build_impl(
        &self,
        iterator: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("IteratorGetNextSync", |nd| {
            nd.add_input(iterator);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'IteratorGetNextSync' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        iterator: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<IteratorGetNextSyncInst> {
        let op = scope.new_operation("IteratorGetNextSync", |builder| {
            builder.add_input(iterator);
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(IteratorGetNextSyncInst { op })
    }
}
impl IteratorGetNextSyncInst {
    /// Returns the 'components' Output of this 'IteratorGetNextSync' operation.
    pub fn components(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'iterator' Input of this 'IteratorGetNextSync' operation.
    pub fn iterator(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<IteratorGetNextSyncInst> for crate::Operation {
    fn from(inst: IteratorGetNextSyncInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `IteratorGetNextSync::new().build(iterator, scope)`.
pub fn iterator_get_next_sync<O0: ::std::convert::Into<crate::Output>>(
    iterator: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    IteratorGetNextSync::new().build(iterator, scope)
}

/// Builder for the `IteratorToStringHandle` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct IteratorToStringHandle {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'IteratorToStringHandle' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct IteratorToStringHandleInst {
    /// An instance of a fully built IteratorToStringHandle Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl IteratorToStringHandle {
    /// Creates a new `IteratorToStringHandle`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `IteratorToStringHandle` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        resource_handle: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(resource_handle.into(), scope)
    }
    fn build_impl(
        &self,
        resource_handle: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("IteratorToStringHandle", |nd| {
            nd.add_input(resource_handle);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'IteratorToStringHandle' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        resource_handle: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<IteratorToStringHandleInst> {
        let op = scope.new_operation("IteratorToStringHandle", |builder| {
            builder.add_input(resource_handle);
            ::std::result::Result::Ok(())
        })?;
        Ok(IteratorToStringHandleInst { op })
    }
}
impl IteratorToStringHandleInst {
    /// Returns the 'string_handle' Output of this 'IteratorToStringHandle' operation.
    pub fn string_handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'resource_handle' Input of this 'IteratorToStringHandle' operation.
    pub fn resource_handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<IteratorToStringHandleInst> for crate::Operation {
    fn from(inst: IteratorToStringHandleInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `IteratorToStringHandle::new().build(resource_handle, scope)`.
pub fn iterator_to_string_handle<O0: ::std::convert::Into<crate::Output>>(
    resource_handle: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    IteratorToStringHandle::new().build(resource_handle, scope)
}

/// Builder for the `IteratorV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct IteratorV2 {
    shared_name: ::std::option::Option<::std::string::String>,
    container: ::std::option::Option<::std::string::String>,
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'IteratorV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct IteratorV2Inst {
    /// An instance of a fully built IteratorV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl IteratorV2 {
    /// Creates a new `IteratorV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `shared_name` attribute.
    pub fn shared_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.shared_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `container` attribute.
    pub fn container<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.container = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `IteratorV2` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("IteratorV2", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                nd.set_attr_string("shared_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.container {
                nd.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'IteratorV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(&self, scope: &mut crate::Scope) -> crate::Result<IteratorV2Inst> {
        let op = scope.new_operation("IteratorV2", |builder| {
            if let ::std::option::Option::Some(value) = &self.shared_name {
                builder.set_attr_string("shared_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.container {
                builder.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(IteratorV2Inst { op })
    }
}
impl IteratorV2Inst {
    /// Returns the 'handle' Output of this 'IteratorV2' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
}
impl From<IteratorV2Inst> for crate::Operation {
    fn from(inst: IteratorV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `IteratorV2::new().build(scope)`.
pub fn iterator_v2(scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
    IteratorV2::new().build(scope)
}

/// Builder for the `KMC2ChainInitialization` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct KMC2ChainInitialization {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'KMC2ChainInitialization' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct KMC2ChainInitializationInst {
    /// An instance of a fully built KMC2ChainInitialization Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl KMC2ChainInitialization {
    /// Creates a new `KMC2ChainInitialization`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `KMC2ChainInitialization` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        distances: O0,
        seed: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(distances.into(), seed.into(), scope)
    }
    fn build_impl(
        &self,
        distances: crate::Output,
        seed: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("KMC2ChainInitialization", |nd| {
            nd.add_input(distances);
            nd.add_input(seed);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'KMC2ChainInitialization' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        distances: crate::Output,
        seed: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<KMC2ChainInitializationInst> {
        let op = scope.new_operation("KMC2ChainInitialization", |builder| {
            builder.add_input(distances);
            builder.add_input(seed);
            ::std::result::Result::Ok(())
        })?;
        Ok(KMC2ChainInitializationInst { op })
    }
}
impl KMC2ChainInitializationInst {
    /// Returns the 'index' Output of this 'KMC2ChainInitialization' operation.
    pub fn index(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'distances' Input of this 'KMC2ChainInitialization' operation.
    pub fn distances(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'seed' Input of this 'KMC2ChainInitialization' operation.
    pub fn seed(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<KMC2ChainInitializationInst> for crate::Operation {
    fn from(inst: KMC2ChainInitializationInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `KMC2ChainInitialization::new().build(distances, seed, scope)`.
pub fn kmc2_chain_initialization<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    distances: O0,
    seed: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    KMC2ChainInitialization::new().build(distances, seed, scope)
}

/// Builder for the `KmeansPlusPlusInitialization` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct KmeansPlusPlusInitialization {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'KmeansPlusPlusInitialization' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct KmeansPlusPlusInitializationInst {
    /// An instance of a fully built KmeansPlusPlusInitialization Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl KmeansPlusPlusInitialization {
    /// Creates a new `KmeansPlusPlusInitialization`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `KmeansPlusPlusInitialization` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
    >(
        &self,
        points: O0,
        num_to_sample: O1,
        seed: O2,
        num_retries_per_sample: O3,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            points.into(),
            num_to_sample.into(),
            seed.into(),
            num_retries_per_sample.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        points: crate::Output,
        num_to_sample: crate::Output,
        seed: crate::Output,
        num_retries_per_sample: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("KmeansPlusPlusInitialization", |nd| {
            nd.add_input(points);
            nd.add_input(num_to_sample);
            nd.add_input(seed);
            nd.add_input(num_retries_per_sample);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'KmeansPlusPlusInitialization' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        points: crate::Output,
        num_to_sample: crate::Output,
        seed: crate::Output,
        num_retries_per_sample: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<KmeansPlusPlusInitializationInst> {
        let op = scope.new_operation("KmeansPlusPlusInitialization", |builder| {
            builder.add_input(points);
            builder.add_input(num_to_sample);
            builder.add_input(seed);
            builder.add_input(num_retries_per_sample);
            ::std::result::Result::Ok(())
        })?;
        Ok(KmeansPlusPlusInitializationInst { op })
    }
}
impl KmeansPlusPlusInitializationInst {
    /// Returns the 'samples' Output of this 'KmeansPlusPlusInitialization' operation.
    pub fn samples(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'points' Input of this 'KmeansPlusPlusInitialization' operation.
    pub fn points(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'num_to_sample' Input of this 'KmeansPlusPlusInitialization' operation.
    pub fn num_to_sample(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'seed' Input of this 'KmeansPlusPlusInitialization' operation.
    pub fn seed(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'num_retries_per_sample' Input of this 'KmeansPlusPlusInitialization' operation.
    pub fn num_retries_per_sample(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
}
impl From<KmeansPlusPlusInitializationInst> for crate::Operation {
    fn from(inst: KmeansPlusPlusInitializationInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `KmeansPlusPlusInitialization::new().build(points, num_to_sample, seed, num_retries_per_sample, scope)`.
pub fn kmeans_plus_plus_initialization<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
>(
    points: O0,
    num_to_sample: O1,
    seed: O2,
    num_retries_per_sample: O3,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    KmeansPlusPlusInitialization::new().build(
        points,
        num_to_sample,
        seed,
        num_retries_per_sample,
        scope,
    )
}

/// Builder for the `KthOrderStatistic` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct KthOrderStatistic {
    k: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'KthOrderStatistic' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct KthOrderStatisticInst {
    /// An instance of a fully built KthOrderStatistic Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl KthOrderStatistic {
    /// Creates a new `KthOrderStatistic`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `k` attribute.
    pub fn k<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.k = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `KthOrderStatistic` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("KthOrderStatistic", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.k {
                nd.set_attr_int("k", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'KthOrderStatistic' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<KthOrderStatisticInst> {
        let op = scope.new_operation("KthOrderStatistic", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.k {
                builder.set_attr_int("k", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(KthOrderStatisticInst { op })
    }
}
impl KthOrderStatisticInst {
    /// Returns the 'output' Output of this 'KthOrderStatistic' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'KthOrderStatistic' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<KthOrderStatisticInst> for crate::Operation {
    fn from(inst: KthOrderStatisticInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `KthOrderStatistic::new().build(input, scope)`.
pub fn kth_order_statistic<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    KthOrderStatistic::new().build(input, scope)
}

/// Builder for the `L2Loss` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct L2Loss {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'L2Loss' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct L2LossInst {
    /// An instance of a fully built L2Loss Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl L2Loss {
    /// Creates a new `L2Loss`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `L2Loss` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        t: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(t.into(), scope)
    }
    fn build_impl(
        &self,
        t: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("L2Loss", |nd| {
            nd.add_input(t);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'L2Loss' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        t: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<L2LossInst> {
        let op = scope.new_operation("L2Loss", |builder| {
            builder.add_input(t);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(L2LossInst { op })
    }
}
impl L2LossInst {
    /// Returns the 'output' Output of this 'L2Loss' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 't' Input of this 'L2Loss' operation.
    pub fn t(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<L2LossInst> for crate::Operation {
    fn from(inst: L2LossInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `L2Loss::new().build(t, scope)`.
pub fn l2_loss<O0: ::std::convert::Into<crate::Output>>(
    t: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    L2Loss::new().build(t, scope)
}

/// Builder for the `LMDBDataset` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct LMDBDataset {
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'LMDBDataset' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct LMDBDatasetInst {
    /// An instance of a fully built LMDBDataset Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl LMDBDataset {
    /// Creates a new `LMDBDataset`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `LMDBDataset` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        filenames: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(filenames.into(), scope)
    }
    fn build_impl(
        &self,
        filenames: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("LMDBDataset", |nd| {
            nd.add_input(filenames);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'LMDBDataset' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        filenames: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<LMDBDatasetInst> {
        let op = scope.new_operation("LMDBDataset", |builder| {
            builder.add_input(filenames);
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(LMDBDatasetInst { op })
    }
}
impl LMDBDatasetInst {
    /// Returns the 'handle' Output of this 'LMDBDataset' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'filenames' Input of this 'LMDBDataset' operation.
    pub fn filenames(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<LMDBDatasetInst> for crate::Operation {
    fn from(inst: LMDBDatasetInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `LMDBDataset::new().build(filenames, scope)`.
pub fn lmdbdataset<O0: ::std::convert::Into<crate::Output>>(
    filenames: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    LMDBDataset::new().build(filenames, scope)
}

/// Builder for the `LMDBReader` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct LMDBReader {
    container: ::std::option::Option<::std::string::String>,
    shared_name: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'LMDBReader' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct LMDBReaderInst {
    /// An instance of a fully built LMDBReader Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl LMDBReader {
    /// Creates a new `LMDBReader`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `container` attribute.
    pub fn container<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.container = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shared_name` attribute.
    pub fn shared_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.shared_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `LMDBReader` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("LMDBReader", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.container {
                nd.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                nd.set_attr_string("shared_name", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'LMDBReader' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(&self, scope: &mut crate::Scope) -> crate::Result<LMDBReaderInst> {
        let op = scope.new_operation("LMDBReader", |builder| {
            if let ::std::option::Option::Some(value) = &self.container {
                builder.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                builder.set_attr_string("shared_name", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(LMDBReaderInst { op })
    }
}
impl LMDBReaderInst {
    /// Returns the 'reader_handle' Output of this 'LMDBReader' operation.
    pub fn reader_handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
}
impl From<LMDBReaderInst> for crate::Operation {
    fn from(inst: LMDBReaderInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `LMDBReader::new().build(scope)`.
pub fn lmdbreader(scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
    LMDBReader::new().build(scope)
}

/// Builder for the `LRN` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct LRN {
    depth_radius: ::std::option::Option<i64>,
    bias: ::std::option::Option<f32>,
    alpha: ::std::option::Option<f32>,
    beta: ::std::option::Option<f32>,
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'LRN' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct LRNInst {
    /// An instance of a fully built LRN Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl LRN {
    /// Creates a new `LRN`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `depth_radius` attribute.
    pub fn depth_radius<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.depth_radius = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `bias` attribute.
    pub fn bias<ArgType: ::std::convert::Into<f32>>(mut self, value: ArgType) -> Self {
        self.bias = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `alpha` attribute.
    pub fn alpha<ArgType: ::std::convert::Into<f32>>(mut self, value: ArgType) -> Self {
        self.alpha = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `beta` attribute.
    pub fn beta<ArgType: ::std::convert::Into<f32>>(mut self, value: ArgType) -> Self {
        self.beta = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `LRN` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("LRN", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.depth_radius {
                nd.set_attr_int("depth_radius", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.bias {
                nd.set_attr_float("bias", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.alpha {
                nd.set_attr_float("alpha", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.beta {
                nd.set_attr_float("beta", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'LRN' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<LRNInst> {
        let op = scope.new_operation("LRN", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.depth_radius {
                builder.set_attr_int("depth_radius", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.bias {
                builder.set_attr_float("bias", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.alpha {
                builder.set_attr_float("alpha", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.beta {
                builder.set_attr_float("beta", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(LRNInst { op })
    }
}
impl LRNInst {
    /// Returns the 'output' Output of this 'LRN' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'LRN' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<LRNInst> for crate::Operation {
    fn from(inst: LRNInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `LRN::new().build(input, scope)`.
pub fn lrn<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    LRN::new().build(input, scope)
}

/// Builder for the `LRNGrad` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct LRNGrad {
    depth_radius: ::std::option::Option<i64>,
    bias: ::std::option::Option<f32>,
    alpha: ::std::option::Option<f32>,
    beta: ::std::option::Option<f32>,
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'LRNGrad' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct LRNGradInst {
    /// An instance of a fully built LRNGrad Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl LRNGrad {
    /// Creates a new `LRNGrad`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `depth_radius` attribute.
    pub fn depth_radius<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.depth_radius = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `bias` attribute.
    pub fn bias<ArgType: ::std::convert::Into<f32>>(mut self, value: ArgType) -> Self {
        self.bias = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `alpha` attribute.
    pub fn alpha<ArgType: ::std::convert::Into<f32>>(mut self, value: ArgType) -> Self {
        self.alpha = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `beta` attribute.
    pub fn beta<ArgType: ::std::convert::Into<f32>>(mut self, value: ArgType) -> Self {
        self.beta = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `LRNGrad` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input_grads: O0,
        input_image: O1,
        output_image: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            input_grads.into(),
            input_image.into(),
            output_image.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        input_grads: crate::Output,
        input_image: crate::Output,
        output_image: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("LRNGrad", |nd| {
            nd.add_input(input_grads);
            nd.add_input(input_image);
            nd.add_input(output_image);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.depth_radius {
                nd.set_attr_int("depth_radius", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.bias {
                nd.set_attr_float("bias", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.alpha {
                nd.set_attr_float("alpha", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.beta {
                nd.set_attr_float("beta", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'LRNGrad' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_grads: crate::Output,
        input_image: crate::Output,
        output_image: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<LRNGradInst> {
        let op = scope.new_operation("LRNGrad", |builder| {
            builder.add_input(input_grads);
            builder.add_input(input_image);
            builder.add_input(output_image);
            if let ::std::option::Option::Some(value) = &self.depth_radius {
                builder.set_attr_int("depth_radius", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.bias {
                builder.set_attr_float("bias", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.alpha {
                builder.set_attr_float("alpha", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.beta {
                builder.set_attr_float("beta", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(LRNGradInst { op })
    }
}
impl LRNGradInst {
    /// Returns the 'output' Output of this 'LRNGrad' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_grads' Input of this 'LRNGrad' operation.
    pub fn input_grads(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'input_image' Input of this 'LRNGrad' operation.
    pub fn input_image(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'output_image' Input of this 'LRNGrad' operation.
    pub fn output_image(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<LRNGradInst> for crate::Operation {
    fn from(inst: LRNGradInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `LRNGrad::new().build(input_grads, input_image, output_image, scope)`.
pub fn lrngrad<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    input_grads: O0,
    input_image: O1,
    output_image: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    LRNGrad::new().build(input_grads, input_image, output_image, scope)
}

/// Builder for the `LSTMBlockCell` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct LSTMBlockCell {
    forget_bias: ::std::option::Option<f32>,
    cell_clip: ::std::option::Option<f32>,
    use_peephole: ::std::option::Option<bool>,
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'LSTMBlockCell' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct LSTMBlockCellInst {
    /// An instance of a fully built LSTMBlockCell Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl LSTMBlockCell {
    /// Creates a new `LSTMBlockCell`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `forget_bias` attribute.
    pub fn forget_bias<ArgType: ::std::convert::Into<f32>>(mut self, value: ArgType) -> Self {
        self.forget_bias = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `cell_clip` attribute.
    pub fn cell_clip<ArgType: ::std::convert::Into<f32>>(mut self, value: ArgType) -> Self {
        self.cell_clip = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_peephole` attribute.
    pub fn use_peephole<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.use_peephole = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `LSTMBlockCell` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
        O6: ::std::convert::Into<crate::Output>,
        O7: ::std::convert::Into<crate::Output>,
    >(
        &self,
        x: O0,
        cs_prev: O1,
        h_prev: O2,
        w: O3,
        wci: O4,
        wcf: O5,
        wco: O6,
        b: O7,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            x.into(),
            cs_prev.into(),
            h_prev.into(),
            w.into(),
            wci.into(),
            wcf.into(),
            wco.into(),
            b.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        x: crate::Output,
        cs_prev: crate::Output,
        h_prev: crate::Output,
        w: crate::Output,
        wci: crate::Output,
        wcf: crate::Output,
        wco: crate::Output,
        b: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("LSTMBlockCell", |nd| {
            nd.add_input(x);
            nd.add_input(cs_prev);
            nd.add_input(h_prev);
            nd.add_input(w);
            nd.add_input(wci);
            nd.add_input(wcf);
            nd.add_input(wco);
            nd.add_input(b);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.forget_bias {
                nd.set_attr_float("forget_bias", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.cell_clip {
                nd.set_attr_float("cell_clip", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_peephole {
                nd.set_attr_bool("use_peephole", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'LSTMBlockCell' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        cs_prev: crate::Output,
        h_prev: crate::Output,
        w: crate::Output,
        wci: crate::Output,
        wcf: crate::Output,
        wco: crate::Output,
        b: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<LSTMBlockCellInst> {
        let op = scope.new_operation("LSTMBlockCell", |builder| {
            builder.add_input(x);
            builder.add_input(cs_prev);
            builder.add_input(h_prev);
            builder.add_input(w);
            builder.add_input(wci);
            builder.add_input(wcf);
            builder.add_input(wco);
            builder.add_input(b);
            if let ::std::option::Option::Some(value) = &self.forget_bias {
                builder.set_attr_float("forget_bias", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.cell_clip {
                builder.set_attr_float("cell_clip", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_peephole {
                builder.set_attr_bool("use_peephole", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(LSTMBlockCellInst { op })
    }
}
impl LSTMBlockCellInst {
    /// Returns the 'i' Output of this 'LSTMBlockCell' operation.
    pub fn i(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'cs' Output of this 'LSTMBlockCell' operation.
    pub fn cs(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'f' Output of this 'LSTMBlockCell' operation.
    pub fn f(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns the 'o' Output of this 'LSTMBlockCell' operation.
    pub fn o(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 3,
        }
    }
    /// Returns the 'ci' Output of this 'LSTMBlockCell' operation.
    pub fn ci(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 4,
        }
    }
    /// Returns the 'co' Output of this 'LSTMBlockCell' operation.
    pub fn co(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 5,
        }
    }
    /// Returns the 'h' Output of this 'LSTMBlockCell' operation.
    pub fn h(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 6,
        }
    }
    /// Returns the 'x' Input of this 'LSTMBlockCell' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'cs_prev' Input of this 'LSTMBlockCell' operation.
    pub fn cs_prev(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'h_prev' Input of this 'LSTMBlockCell' operation.
    pub fn h_prev(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'w' Input of this 'LSTMBlockCell' operation.
    pub fn w(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'wci' Input of this 'LSTMBlockCell' operation.
    pub fn wci(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
    /// Returns the 'wcf' Input of this 'LSTMBlockCell' operation.
    pub fn wcf(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 5,
        }
    }
    /// Returns the 'wco' Input of this 'LSTMBlockCell' operation.
    pub fn wco(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 6,
        }
    }
    /// Returns the 'b' Input of this 'LSTMBlockCell' operation.
    pub fn b(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 7,
        }
    }
}
impl From<LSTMBlockCellInst> for crate::Operation {
    fn from(inst: LSTMBlockCellInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `LSTMBlockCell::new().build(x, cs_prev, h_prev, w, wci, wcf, wco, b, scope)`.
pub fn lstmblock_cell<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
    O6: ::std::convert::Into<crate::Output>,
    O7: ::std::convert::Into<crate::Output>,
>(
    x: O0,
    cs_prev: O1,
    h_prev: O2,
    w: O3,
    wci: O4,
    wcf: O5,
    wco: O6,
    b: O7,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    LSTMBlockCell::new().build(x, cs_prev, h_prev, w, wci, wcf, wco, b, scope)
}

/// Builder for the `LSTMBlockCellGrad` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct LSTMBlockCellGrad {
    use_peephole: ::std::option::Option<bool>,
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'LSTMBlockCellGrad' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct LSTMBlockCellGradInst {
    /// An instance of a fully built LSTMBlockCellGrad Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl LSTMBlockCellGrad {
    /// Creates a new `LSTMBlockCellGrad`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `use_peephole` attribute.
    pub fn use_peephole<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.use_peephole = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `LSTMBlockCellGrad` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
        O6: ::std::convert::Into<crate::Output>,
        O7: ::std::convert::Into<crate::Output>,
        O8: ::std::convert::Into<crate::Output>,
        O9: ::std::convert::Into<crate::Output>,
        O10: ::std::convert::Into<crate::Output>,
        O11: ::std::convert::Into<crate::Output>,
        O12: ::std::convert::Into<crate::Output>,
        O13: ::std::convert::Into<crate::Output>,
        O14: ::std::convert::Into<crate::Output>,
        O15: ::std::convert::Into<crate::Output>,
    >(
        &self,
        x: O0,
        cs_prev: O1,
        h_prev: O2,
        w: O3,
        wci: O4,
        wcf: O5,
        wco: O6,
        b: O7,
        i: O8,
        cs: O9,
        f: O10,
        o: O11,
        ci: O12,
        co: O13,
        cs_grad: O14,
        h_grad: O15,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            x.into(),
            cs_prev.into(),
            h_prev.into(),
            w.into(),
            wci.into(),
            wcf.into(),
            wco.into(),
            b.into(),
            i.into(),
            cs.into(),
            f.into(),
            o.into(),
            ci.into(),
            co.into(),
            cs_grad.into(),
            h_grad.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        x: crate::Output,
        cs_prev: crate::Output,
        h_prev: crate::Output,
        w: crate::Output,
        wci: crate::Output,
        wcf: crate::Output,
        wco: crate::Output,
        b: crate::Output,
        i: crate::Output,
        cs: crate::Output,
        f: crate::Output,
        o: crate::Output,
        ci: crate::Output,
        co: crate::Output,
        cs_grad: crate::Output,
        h_grad: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("LSTMBlockCellGrad", |nd| {
            nd.add_input(x);
            nd.add_input(cs_prev);
            nd.add_input(h_prev);
            nd.add_input(w);
            nd.add_input(wci);
            nd.add_input(wcf);
            nd.add_input(wco);
            nd.add_input(b);
            nd.add_input(i);
            nd.add_input(cs);
            nd.add_input(f);
            nd.add_input(o);
            nd.add_input(ci);
            nd.add_input(co);
            nd.add_input(cs_grad);
            nd.add_input(h_grad);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.use_peephole {
                nd.set_attr_bool("use_peephole", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'LSTMBlockCellGrad' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        cs_prev: crate::Output,
        h_prev: crate::Output,
        w: crate::Output,
        wci: crate::Output,
        wcf: crate::Output,
        wco: crate::Output,
        b: crate::Output,
        i: crate::Output,
        cs: crate::Output,
        f: crate::Output,
        o: crate::Output,
        ci: crate::Output,
        co: crate::Output,
        cs_grad: crate::Output,
        h_grad: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<LSTMBlockCellGradInst> {
        let op = scope.new_operation("LSTMBlockCellGrad", |builder| {
            builder.add_input(x);
            builder.add_input(cs_prev);
            builder.add_input(h_prev);
            builder.add_input(w);
            builder.add_input(wci);
            builder.add_input(wcf);
            builder.add_input(wco);
            builder.add_input(b);
            builder.add_input(i);
            builder.add_input(cs);
            builder.add_input(f);
            builder.add_input(o);
            builder.add_input(ci);
            builder.add_input(co);
            builder.add_input(cs_grad);
            builder.add_input(h_grad);
            if let ::std::option::Option::Some(value) = &self.use_peephole {
                builder.set_attr_bool("use_peephole", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(LSTMBlockCellGradInst { op })
    }
}
impl LSTMBlockCellGradInst {
    /// Returns the 'cs_prev_grad' Output of this 'LSTMBlockCellGrad' operation.
    pub fn cs_prev_grad(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'dicfo' Output of this 'LSTMBlockCellGrad' operation.
    pub fn dicfo(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'wci_grad' Output of this 'LSTMBlockCellGrad' operation.
    pub fn wci_grad(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns the 'wcf_grad' Output of this 'LSTMBlockCellGrad' operation.
    pub fn wcf_grad(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 3,
        }
    }
    /// Returns the 'wco_grad' Output of this 'LSTMBlockCellGrad' operation.
    pub fn wco_grad(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 4,
        }
    }
    /// Returns the 'x' Input of this 'LSTMBlockCellGrad' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'cs_prev' Input of this 'LSTMBlockCellGrad' operation.
    pub fn cs_prev(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'h_prev' Input of this 'LSTMBlockCellGrad' operation.
    pub fn h_prev(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'w' Input of this 'LSTMBlockCellGrad' operation.
    pub fn w(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'wci' Input of this 'LSTMBlockCellGrad' operation.
    pub fn wci(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
    /// Returns the 'wcf' Input of this 'LSTMBlockCellGrad' operation.
    pub fn wcf(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 5,
        }
    }
    /// Returns the 'wco' Input of this 'LSTMBlockCellGrad' operation.
    pub fn wco(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 6,
        }
    }
    /// Returns the 'b' Input of this 'LSTMBlockCellGrad' operation.
    pub fn b(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 7,
        }
    }
    /// Returns the 'i' Input of this 'LSTMBlockCellGrad' operation.
    pub fn i(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 8,
        }
    }
    /// Returns the 'cs' Input of this 'LSTMBlockCellGrad' operation.
    pub fn cs(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 9,
        }
    }
    /// Returns the 'f' Input of this 'LSTMBlockCellGrad' operation.
    pub fn f(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 10,
        }
    }
    /// Returns the 'o' Input of this 'LSTMBlockCellGrad' operation.
    pub fn o(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 11,
        }
    }
    /// Returns the 'ci' Input of this 'LSTMBlockCellGrad' operation.
    pub fn ci(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 12,
        }
    }
    /// Returns the 'co' Input of this 'LSTMBlockCellGrad' operation.
    pub fn co(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 13,
        }
    }
    /// Returns the 'cs_grad' Input of this 'LSTMBlockCellGrad' operation.
    pub fn cs_grad(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 14,
        }
    }
    /// Returns the 'h_grad' Input of this 'LSTMBlockCellGrad' operation.
    pub fn h_grad(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 15,
        }
    }
}
impl From<LSTMBlockCellGradInst> for crate::Operation {
    fn from(inst: LSTMBlockCellGradInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `LSTMBlockCellGrad::new().build(x, cs_prev, h_prev, w, wci, wcf, wco, b, i, cs, f, o, ci, co, cs_grad, h_grad, scope)`.
pub fn lstmblock_cell_grad<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
    O6: ::std::convert::Into<crate::Output>,
    O7: ::std::convert::Into<crate::Output>,
    O8: ::std::convert::Into<crate::Output>,
    O9: ::std::convert::Into<crate::Output>,
    O10: ::std::convert::Into<crate::Output>,
    O11: ::std::convert::Into<crate::Output>,
    O12: ::std::convert::Into<crate::Output>,
    O13: ::std::convert::Into<crate::Output>,
    O14: ::std::convert::Into<crate::Output>,
    O15: ::std::convert::Into<crate::Output>,
>(
    x: O0,
    cs_prev: O1,
    h_prev: O2,
    w: O3,
    wci: O4,
    wcf: O5,
    wco: O6,
    b: O7,
    i: O8,
    cs: O9,
    f: O10,
    o: O11,
    ci: O12,
    co: O13,
    cs_grad: O14,
    h_grad: O15,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    LSTMBlockCellGrad::new().build(
        x, cs_prev, h_prev, w, wci, wcf, wco, b, i, cs, f, o, ci, co, cs_grad, h_grad, scope,
    )
}

/// Builder for the `LatencyStatsDataset` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct LatencyStatsDataset {
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'LatencyStatsDataset' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct LatencyStatsDatasetInst {
    /// An instance of a fully built LatencyStatsDataset Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl LatencyStatsDataset {
    /// Creates a new `LatencyStatsDataset`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `LatencyStatsDataset` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input_dataset: O0,
        tag: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input_dataset.into(), tag.into(), scope)
    }
    fn build_impl(
        &self,
        input_dataset: crate::Output,
        tag: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("LatencyStatsDataset", |nd| {
            nd.add_input(input_dataset);
            nd.add_input(tag);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'LatencyStatsDataset' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_dataset: crate::Output,
        tag: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<LatencyStatsDatasetInst> {
        let op = scope.new_operation("LatencyStatsDataset", |builder| {
            builder.add_input(input_dataset);
            builder.add_input(tag);
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(LatencyStatsDatasetInst { op })
    }
}
impl LatencyStatsDatasetInst {
    /// Returns the 'handle' Output of this 'LatencyStatsDataset' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_dataset' Input of this 'LatencyStatsDataset' operation.
    pub fn input_dataset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'tag' Input of this 'LatencyStatsDataset' operation.
    pub fn tag(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<LatencyStatsDatasetInst> for crate::Operation {
    fn from(inst: LatencyStatsDatasetInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `LatencyStatsDataset::new().build(input_dataset, tag, scope)`.
pub fn latency_stats_dataset<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    input_dataset: O0,
    tag: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    LatencyStatsDataset::new().build(input_dataset, tag, scope)
}

/// Builder for the `LeakyRelu` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct LeakyRelu {
    alpha: ::std::option::Option<f32>,
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'LeakyRelu' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct LeakyReluInst {
    /// An instance of a fully built LeakyRelu Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl LeakyRelu {
    /// Creates a new `LeakyRelu`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `alpha` attribute.
    pub fn alpha<ArgType: ::std::convert::Into<f32>>(mut self, value: ArgType) -> Self {
        self.alpha = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `LeakyRelu` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        features: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(features.into(), scope)
    }
    fn build_impl(
        &self,
        features: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("LeakyRelu", |nd| {
            nd.add_input(features);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.alpha {
                nd.set_attr_float("alpha", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'LeakyRelu' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        features: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<LeakyReluInst> {
        let op = scope.new_operation("LeakyRelu", |builder| {
            builder.add_input(features);
            if let ::std::option::Option::Some(value) = &self.alpha {
                builder.set_attr_float("alpha", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(LeakyReluInst { op })
    }
}
impl LeakyReluInst {
    /// Returns the 'activations' Output of this 'LeakyRelu' operation.
    pub fn activations(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'features' Input of this 'LeakyRelu' operation.
    pub fn features(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<LeakyReluInst> for crate::Operation {
    fn from(inst: LeakyReluInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `LeakyRelu::new().build(features, scope)`.
pub fn leaky_relu<O0: ::std::convert::Into<crate::Output>>(
    features: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    LeakyRelu::new().build(features, scope)
}

/// Builder for the `LeakyReluGrad` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct LeakyReluGrad {
    alpha: ::std::option::Option<f32>,
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'LeakyReluGrad' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct LeakyReluGradInst {
    /// An instance of a fully built LeakyReluGrad Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl LeakyReluGrad {
    /// Creates a new `LeakyReluGrad`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `alpha` attribute.
    pub fn alpha<ArgType: ::std::convert::Into<f32>>(mut self, value: ArgType) -> Self {
        self.alpha = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `LeakyReluGrad` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        gradients: O0,
        features: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(gradients.into(), features.into(), scope)
    }
    fn build_impl(
        &self,
        gradients: crate::Output,
        features: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("LeakyReluGrad", |nd| {
            nd.add_input(gradients);
            nd.add_input(features);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.alpha {
                nd.set_attr_float("alpha", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'LeakyReluGrad' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        gradients: crate::Output,
        features: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<LeakyReluGradInst> {
        let op = scope.new_operation("LeakyReluGrad", |builder| {
            builder.add_input(gradients);
            builder.add_input(features);
            if let ::std::option::Option::Some(value) = &self.alpha {
                builder.set_attr_float("alpha", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(LeakyReluGradInst { op })
    }
}
impl LeakyReluGradInst {
    /// Returns the 'backprops' Output of this 'LeakyReluGrad' operation.
    pub fn backprops(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'gradients' Input of this 'LeakyReluGrad' operation.
    pub fn gradients(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'features' Input of this 'LeakyReluGrad' operation.
    pub fn features(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<LeakyReluGradInst> for crate::Operation {
    fn from(inst: LeakyReluGradInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `LeakyReluGrad::new().build(gradients, features, scope)`.
pub fn leaky_relu_grad<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    gradients: O0,
    features: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    LeakyReluGrad::new().build(gradients, features, scope)
}

/// Builder for the `LearnedUnigramCandidateSampler` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct LearnedUnigramCandidateSampler {
    num_true: ::std::option::Option<i64>,
    num_sampled: ::std::option::Option<i64>,
    unique: ::std::option::Option<bool>,
    range_max: ::std::option::Option<i64>,
    seed: ::std::option::Option<i64>,
    seed2: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'LearnedUnigramCandidateSampler' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct LearnedUnigramCandidateSamplerInst {
    /// An instance of a fully built LearnedUnigramCandidateSampler Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl LearnedUnigramCandidateSampler {
    /// Creates a new `LearnedUnigramCandidateSampler`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `num_true` attribute.
    pub fn num_true<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.num_true = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `num_sampled` attribute.
    pub fn num_sampled<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.num_sampled = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `unique` attribute.
    pub fn unique<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.unique = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `range_max` attribute.
    pub fn range_max<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.range_max = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `seed` attribute.
    pub fn seed<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.seed = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `seed2` attribute.
    pub fn seed2<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.seed2 = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `LearnedUnigramCandidateSampler` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        true_classes: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(true_classes.into(), scope)
    }
    fn build_impl(
        &self,
        true_classes: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("LearnedUnigramCandidateSampler", |nd| {
            nd.add_input(true_classes);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.num_true {
                nd.set_attr_int("num_true", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_sampled {
                nd.set_attr_int("num_sampled", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.unique {
                nd.set_attr_bool("unique", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.range_max {
                nd.set_attr_int("range_max", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed {
                nd.set_attr_int("seed", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed2 {
                nd.set_attr_int("seed2", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'LearnedUnigramCandidateSampler' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        true_classes: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<LearnedUnigramCandidateSamplerInst> {
        let op = scope.new_operation("LearnedUnigramCandidateSampler", |builder| {
            builder.add_input(true_classes);
            if let ::std::option::Option::Some(value) = &self.num_true {
                builder.set_attr_int("num_true", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_sampled {
                builder.set_attr_int("num_sampled", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.unique {
                builder.set_attr_bool("unique", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.range_max {
                builder.set_attr_int("range_max", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed {
                builder.set_attr_int("seed", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed2 {
                builder.set_attr_int("seed2", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(LearnedUnigramCandidateSamplerInst { op })
    }
}
impl LearnedUnigramCandidateSamplerInst {
    /// Returns the 'sampled_candidates' Output of this 'LearnedUnigramCandidateSampler' operation.
    pub fn sampled_candidates(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'true_expected_count' Output of this 'LearnedUnigramCandidateSampler' operation.
    pub fn true_expected_count(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'sampled_expected_count' Output of this 'LearnedUnigramCandidateSampler' operation.
    pub fn sampled_expected_count(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns the 'true_classes' Input of this 'LearnedUnigramCandidateSampler' operation.
    pub fn true_classes(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<LearnedUnigramCandidateSamplerInst> for crate::Operation {
    fn from(inst: LearnedUnigramCandidateSamplerInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `LearnedUnigramCandidateSampler::new().build(true_classes, scope)`.
pub fn learned_unigram_candidate_sampler<O0: ::std::convert::Into<crate::Output>>(
    true_classes: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    LearnedUnigramCandidateSampler::new().build(true_classes, scope)
}

/// Builder for the `LeftShift` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct LeftShift {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'LeftShift' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct LeftShiftInst {
    /// An instance of a fully built LeftShift Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl LeftShift {
    /// Creates a new `LeftShift`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `LeftShift` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        x: O0,
        y: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), y.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        y: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("LeftShift", |nd| {
            nd.add_input(x);
            nd.add_input(y);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'LeftShift' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        y: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<LeftShiftInst> {
        let op = scope.new_operation("LeftShift", |builder| {
            builder.add_input(x);
            builder.add_input(y);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(LeftShiftInst { op })
    }
}
impl LeftShiftInst {
    /// Returns the 'z' Output of this 'LeftShift' operation.
    pub fn z(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'LeftShift' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'y' Input of this 'LeftShift' operation.
    pub fn y(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<LeftShiftInst> for crate::Operation {
    fn from(inst: LeftShiftInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `LeftShift::new().build(x, y, scope)`.
pub fn left_shift<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    x: O0,
    y: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    LeftShift::new().build(x, y, scope)
}

/// Builder for the `LegacyParallelInterleaveDatasetV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct LegacyParallelInterleaveDatasetV2 {
    f: ::std::option::Option<::std::string::String>,
    deterministic: ::std::option::Option<::std::string::String>,
    Targuments: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    metadata: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'LegacyParallelInterleaveDatasetV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct LegacyParallelInterleaveDatasetV2Inst {
    /// An instance of a fully built LegacyParallelInterleaveDatasetV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl LegacyParallelInterleaveDatasetV2 {
    /// Creates a new `LegacyParallelInterleaveDatasetV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `f` attribute.
    pub fn f<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.f = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `deterministic` attribute.
    pub fn deterministic<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.deterministic = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Targuments` attribute.
    pub fn Targuments<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Targuments = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `metadata` attribute.
    pub fn metadata<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.metadata = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `LegacyParallelInterleaveDatasetV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input_dataset: O0,
        other_arguments: O1,
        cycle_length: O2,
        block_length: O3,
        buffer_output_elements: O4,
        prefetch_input_elements: O5,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            input_dataset.into(),
            other_arguments.into(),
            cycle_length.into(),
            block_length.into(),
            buffer_output_elements.into(),
            prefetch_input_elements.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        input_dataset: crate::Output,
        other_arguments: crate::Output,
        cycle_length: crate::Output,
        block_length: crate::Output,
        buffer_output_elements: crate::Output,
        prefetch_input_elements: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("LegacyParallelInterleaveDatasetV2", |nd| {
            nd.add_input(input_dataset);
            nd.add_input(other_arguments);
            nd.add_input(cycle_length);
            nd.add_input(block_length);
            nd.add_input(buffer_output_elements);
            nd.add_input(prefetch_input_elements);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.f {
                nd.set_attr_string("f", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.deterministic {
                nd.set_attr_string("deterministic", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Targuments {
                nd.set_attr_type_list("Targuments", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.metadata {
                nd.set_attr_string("metadata", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'LegacyParallelInterleaveDatasetV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_dataset: crate::Output,
        other_arguments: crate::Output,
        cycle_length: crate::Output,
        block_length: crate::Output,
        buffer_output_elements: crate::Output,
        prefetch_input_elements: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<LegacyParallelInterleaveDatasetV2Inst> {
        let op = scope.new_operation("LegacyParallelInterleaveDatasetV2", |builder| {
            builder.add_input(input_dataset);
            builder.add_input(other_arguments);
            builder.add_input(cycle_length);
            builder.add_input(block_length);
            builder.add_input(buffer_output_elements);
            builder.add_input(prefetch_input_elements);
            if let ::std::option::Option::Some(value) = &self.f {
                builder.set_attr_string("f", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.deterministic {
                builder.set_attr_string("deterministic", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Targuments {
                builder.set_attr_type_list("Targuments", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.metadata {
                builder.set_attr_string("metadata", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(LegacyParallelInterleaveDatasetV2Inst { op })
    }
}
impl LegacyParallelInterleaveDatasetV2Inst {
    /// Returns the 'handle' Output of this 'LegacyParallelInterleaveDatasetV2' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_dataset' Input of this 'LegacyParallelInterleaveDatasetV2' operation.
    pub fn input_dataset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'other_arguments' Input of this 'LegacyParallelInterleaveDatasetV2' operation.
    pub fn other_arguments(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'cycle_length' Input of this 'LegacyParallelInterleaveDatasetV2' operation.
    pub fn cycle_length(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'block_length' Input of this 'LegacyParallelInterleaveDatasetV2' operation.
    pub fn block_length(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'buffer_output_elements' Input of this 'LegacyParallelInterleaveDatasetV2' operation.
    pub fn buffer_output_elements(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
    /// Returns the 'prefetch_input_elements' Input of this 'LegacyParallelInterleaveDatasetV2' operation.
    pub fn prefetch_input_elements(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 5,
        }
    }
}
impl From<LegacyParallelInterleaveDatasetV2Inst> for crate::Operation {
    fn from(inst: LegacyParallelInterleaveDatasetV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `LegacyParallelInterleaveDatasetV2::new().build(input_dataset, other_arguments, cycle_length, block_length, buffer_output_elements, prefetch_input_elements, scope)`.
pub fn legacy_parallel_interleave_dataset_v2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
>(
    input_dataset: O0,
    other_arguments: O1,
    cycle_length: O2,
    block_length: O3,
    buffer_output_elements: O4,
    prefetch_input_elements: O5,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    LegacyParallelInterleaveDatasetV2::new().build(
        input_dataset,
        other_arguments,
        cycle_length,
        block_length,
        buffer_output_elements,
        prefetch_input_elements,
        scope,
    )
}

/// Builder for the `Less` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Less {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Less' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct LessInst {
    /// An instance of a fully built Less Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Less {
    /// Creates a new `Less`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Less` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        x: O0,
        y: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), y.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        y: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Less", |nd| {
            nd.add_input(x);
            nd.add_input(y);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Less' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        y: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<LessInst> {
        let op = scope.new_operation("Less", |builder| {
            builder.add_input(x);
            builder.add_input(y);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(LessInst { op })
    }
}
impl LessInst {
    /// Returns the 'z' Output of this 'Less' operation.
    pub fn z(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'Less' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'y' Input of this 'Less' operation.
    pub fn y(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<LessInst> for crate::Operation {
    fn from(inst: LessInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Less::new().build(x, y, scope)`.
pub fn less<O0: ::std::convert::Into<crate::Output>, O1: ::std::convert::Into<crate::Output>>(
    x: O0,
    y: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Less::new().build(x, y, scope)
}

/// Builder for the `LessEqual` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct LessEqual {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'LessEqual' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct LessEqualInst {
    /// An instance of a fully built LessEqual Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl LessEqual {
    /// Creates a new `LessEqual`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `LessEqual` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        x: O0,
        y: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), y.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        y: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("LessEqual", |nd| {
            nd.add_input(x);
            nd.add_input(y);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'LessEqual' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        y: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<LessEqualInst> {
        let op = scope.new_operation("LessEqual", |builder| {
            builder.add_input(x);
            builder.add_input(y);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(LessEqualInst { op })
    }
}
impl LessEqualInst {
    /// Returns the 'z' Output of this 'LessEqual' operation.
    pub fn z(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'LessEqual' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'y' Input of this 'LessEqual' operation.
    pub fn y(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<LessEqualInst> for crate::Operation {
    fn from(inst: LessEqualInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `LessEqual::new().build(x, y, scope)`.
pub fn less_equal<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    x: O0,
    y: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    LessEqual::new().build(x, y, scope)
}

/// Builder for the `Lgamma` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Lgamma {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Lgamma' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct LgammaInst {
    /// An instance of a fully built Lgamma Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Lgamma {
    /// Creates a new `Lgamma`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Lgamma` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        x: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Lgamma", |nd| {
            nd.add_input(x);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Lgamma' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<LgammaInst> {
        let op = scope.new_operation("Lgamma", |builder| {
            builder.add_input(x);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(LgammaInst { op })
    }
}
impl LgammaInst {
    /// Returns the 'y' Output of this 'Lgamma' operation.
    pub fn y(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'Lgamma' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<LgammaInst> for crate::Operation {
    fn from(inst: LgammaInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Lgamma::new().build(x, scope)`.
pub fn lgamma<O0: ::std::convert::Into<crate::Output>>(
    x: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Lgamma::new().build(x, scope)
}

/// Builder for the `LinSpace` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct LinSpace {
    T: ::std::option::Option<crate::DataType>,
    Tidx: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'LinSpace' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct LinSpaceInst {
    /// An instance of a fully built LinSpace Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl LinSpace {
    /// Creates a new `LinSpace`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tidx` attribute.
    pub fn Tidx<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Tidx = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `LinSpace` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        start: O0,
        stop: O1,
        num: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(start.into(), stop.into(), num.into(), scope)
    }
    fn build_impl(
        &self,
        start: crate::Output,
        stop: crate::Output,
        num: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("LinSpace", |nd| {
            nd.add_input(start);
            nd.add_input(stop);
            nd.add_input(num);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tidx {
                nd.set_attr_type("Tidx", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'LinSpace' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        start: crate::Output,
        stop: crate::Output,
        num: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<LinSpaceInst> {
        let op = scope.new_operation("LinSpace", |builder| {
            builder.add_input(start);
            builder.add_input(stop);
            builder.add_input(num);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tidx {
                builder.set_attr_type("Tidx", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(LinSpaceInst { op })
    }
}
impl LinSpaceInst {
    /// Returns the 'output' Output of this 'LinSpace' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'start' Input of this 'LinSpace' operation.
    pub fn start(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'stop' Input of this 'LinSpace' operation.
    pub fn stop(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'num' Input of this 'LinSpace' operation.
    pub fn num(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<LinSpaceInst> for crate::Operation {
    fn from(inst: LinSpaceInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `LinSpace::new().build(start, stop, num, scope)`.
pub fn lin_space<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    start: O0,
    stop: O1,
    num: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    LinSpace::new().build(start, stop, num, scope)
}

/// Builder for the `ListDataset` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ListDataset {
    Tinput_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    metadata: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ListDataset' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ListDatasetInst {
    /// An instance of a fully built ListDataset Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ListDataset {
    /// Creates a new `ListDataset`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `Tinput_types` attribute.
    pub fn Tinput_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tinput_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `metadata` attribute.
    pub fn metadata<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.metadata = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ListDataset` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        tensors: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(tensors.into(), scope)
    }
    fn build_impl(
        &self,
        tensors: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ListDataset", |nd| {
            nd.add_input(tensors);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.Tinput_types {
                nd.set_attr_type_list("Tinput_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.metadata {
                nd.set_attr_string("metadata", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ListDataset' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        tensors: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ListDatasetInst> {
        let op = scope.new_operation("ListDataset", |builder| {
            builder.add_input(tensors);
            if let ::std::option::Option::Some(value) = &self.Tinput_types {
                builder.set_attr_type_list("Tinput_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.metadata {
                builder.set_attr_string("metadata", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ListDatasetInst { op })
    }
}
impl ListDatasetInst {
    /// Returns the 'handle' Output of this 'ListDataset' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'tensors' Input of this 'ListDataset' operation.
    pub fn tensors(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<ListDatasetInst> for crate::Operation {
    fn from(inst: ListDatasetInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ListDataset::new().build(tensors, scope)`.
pub fn list_dataset<O0: ::std::convert::Into<crate::Output>>(
    tensors: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ListDataset::new().build(tensors, scope)
}

/// Builder for the `ListDiff` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ListDiff {
    T: ::std::option::Option<crate::DataType>,
    out_idx: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ListDiff' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ListDiffInst {
    /// An instance of a fully built ListDiff Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ListDiff {
    /// Creates a new `ListDiff`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `out_idx` attribute.
    pub fn out_idx<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.out_idx = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ListDiff` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        x: O0,
        y: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), y.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        y: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ListDiff", |nd| {
            nd.add_input(x);
            nd.add_input(y);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.out_idx {
                nd.set_attr_type("out_idx", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ListDiff' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        y: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ListDiffInst> {
        let op = scope.new_operation("ListDiff", |builder| {
            builder.add_input(x);
            builder.add_input(y);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.out_idx {
                builder.set_attr_type("out_idx", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ListDiffInst { op })
    }
}
impl ListDiffInst {
    /// Returns the 'out' Output of this 'ListDiff' operation.
    pub fn out(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'idx' Output of this 'ListDiff' operation.
    pub fn idx(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'x' Input of this 'ListDiff' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'y' Input of this 'ListDiff' operation.
    pub fn y(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<ListDiffInst> for crate::Operation {
    fn from(inst: ListDiffInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ListDiff::new().build(x, y, scope)`.
pub fn list_diff<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    x: O0,
    y: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ListDiff::new().build(x, y, scope)
}

/// Builder for the `LoadAllTPUEmbeddingParameters` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct LoadAllTPUEmbeddingParameters {
    NumTables: ::std::option::Option<i64>,
    config: ::std::option::Option<::std::string::String>,
    num_shards: ::std::option::Option<i64>,
    shard_id: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'LoadAllTPUEmbeddingParameters' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct LoadAllTPUEmbeddingParametersInst {
    /// An instance of a fully built LoadAllTPUEmbeddingParameters Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl LoadAllTPUEmbeddingParameters {
    /// Creates a new `LoadAllTPUEmbeddingParameters`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `NumTables` attribute.
    pub fn NumTables<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.NumTables = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `config` attribute.
    pub fn config<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.config = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `num_shards` attribute.
    pub fn num_shards<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.num_shards = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shard_id` attribute.
    pub fn shard_id<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.shard_id = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `LoadAllTPUEmbeddingParameters` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
        O6: ::std::convert::Into<crate::Output>,
        O7: ::std::convert::Into<crate::Output>,
    >(
        &self,
        parameters: O0,
        auxiliary1: O1,
        auxiliary2: O2,
        auxiliary3: O3,
        auxiliary4: O4,
        auxiliary5: O5,
        auxiliary6: O6,
        auxiliary7: O7,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            parameters.into(),
            auxiliary1.into(),
            auxiliary2.into(),
            auxiliary3.into(),
            auxiliary4.into(),
            auxiliary5.into(),
            auxiliary6.into(),
            auxiliary7.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        parameters: crate::Output,
        auxiliary1: crate::Output,
        auxiliary2: crate::Output,
        auxiliary3: crate::Output,
        auxiliary4: crate::Output,
        auxiliary5: crate::Output,
        auxiliary6: crate::Output,
        auxiliary7: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("LoadAllTPUEmbeddingParameters", |nd| {
            nd.add_input(parameters);
            nd.add_input(auxiliary1);
            nd.add_input(auxiliary2);
            nd.add_input(auxiliary3);
            nd.add_input(auxiliary4);
            nd.add_input(auxiliary5);
            nd.add_input(auxiliary6);
            nd.add_input(auxiliary7);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.NumTables {
                nd.set_attr_int("NumTables", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.config {
                nd.set_attr_string("config", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_shards {
                nd.set_attr_int("num_shards", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shard_id {
                nd.set_attr_int("shard_id", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'LoadAllTPUEmbeddingParameters' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        parameters: Vec<crate::Output>,
        auxiliary1: Vec<crate::Output>,
        auxiliary2: Vec<crate::Output>,
        auxiliary3: Vec<crate::Output>,
        auxiliary4: Vec<crate::Output>,
        auxiliary5: Vec<crate::Output>,
        auxiliary6: Vec<crate::Output>,
        auxiliary7: Vec<crate::Output>,
        scope: &mut crate::Scope,
    ) -> crate::Result<LoadAllTPUEmbeddingParametersInst> {
        let op = scope.new_operation("LoadAllTPUEmbeddingParameters", |builder| {
            builder.add_input_list(&parameters);
            builder.add_input_list(&auxiliary1);
            builder.add_input_list(&auxiliary2);
            builder.add_input_list(&auxiliary3);
            builder.add_input_list(&auxiliary4);
            builder.add_input_list(&auxiliary5);
            builder.add_input_list(&auxiliary6);
            builder.add_input_list(&auxiliary7);
            builder.set_attr_int("NumTables", parameters.clone().len() as i64)?;
            if let ::std::option::Option::Some(value) = &self.config {
                builder.set_attr_string("config", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_shards {
                builder.set_attr_int("num_shards", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shard_id {
                builder.set_attr_int("shard_id", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(LoadAllTPUEmbeddingParametersInst { op })
    }
}
impl LoadAllTPUEmbeddingParametersInst {
    /// Returns a Vector of parameters for 'parameters' Input of this LoadAllTPUEmbeddingParameters operation.
    pub fn parameters(&self) -> crate::Result<Vec<crate::Input>> {
        let mut Inputs = vec![];
        for i in 0..self.op.get_attr_int("NumTables")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
    /// Returns a Vector of auxiliary1 for 'auxiliary1' Input of this LoadAllTPUEmbeddingParameters operation.
    pub fn auxiliary1(&self) -> crate::Result<Vec<crate::Input>> {
        let dynamic_offset = (self.op.get_attr_int("NumTables")? + 1) as i32;
        let mut Inputs = vec![];
        for i in dynamic_offset..dynamic_offset + self.op.get_attr_int("NumTables")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
    /// Returns a Vector of auxiliary2 for 'auxiliary2' Input of this LoadAllTPUEmbeddingParameters operation.
    pub fn auxiliary2(&self) -> crate::Result<Vec<crate::Input>> {
        let dynamic_offset = (2 * self.op.get_attr_int("NumTables")? + 2) as i32;
        let mut Inputs = vec![];
        for i in dynamic_offset..dynamic_offset + self.op.get_attr_int("NumTables")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
    /// Returns a Vector of auxiliary3 for 'auxiliary3' Input of this LoadAllTPUEmbeddingParameters operation.
    pub fn auxiliary3(&self) -> crate::Result<Vec<crate::Input>> {
        let dynamic_offset = (3 * self.op.get_attr_int("NumTables")? + 3) as i32;
        let mut Inputs = vec![];
        for i in dynamic_offset..dynamic_offset + self.op.get_attr_int("NumTables")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
    /// Returns a Vector of auxiliary4 for 'auxiliary4' Input of this LoadAllTPUEmbeddingParameters operation.
    pub fn auxiliary4(&self) -> crate::Result<Vec<crate::Input>> {
        let dynamic_offset = (4 * self.op.get_attr_int("NumTables")? + 4) as i32;
        let mut Inputs = vec![];
        for i in dynamic_offset..dynamic_offset + self.op.get_attr_int("NumTables")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
    /// Returns a Vector of auxiliary5 for 'auxiliary5' Input of this LoadAllTPUEmbeddingParameters operation.
    pub fn auxiliary5(&self) -> crate::Result<Vec<crate::Input>> {
        let dynamic_offset = (5 * self.op.get_attr_int("NumTables")? + 5) as i32;
        let mut Inputs = vec![];
        for i in dynamic_offset..dynamic_offset + self.op.get_attr_int("NumTables")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
    /// Returns a Vector of auxiliary6 for 'auxiliary6' Input of this LoadAllTPUEmbeddingParameters operation.
    pub fn auxiliary6(&self) -> crate::Result<Vec<crate::Input>> {
        let dynamic_offset = (6 * self.op.get_attr_int("NumTables")? + 6) as i32;
        let mut Inputs = vec![];
        for i in dynamic_offset..dynamic_offset + self.op.get_attr_int("NumTables")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
    /// Returns a Vector of auxiliary7 for 'auxiliary7' Input of this LoadAllTPUEmbeddingParameters operation.
    pub fn auxiliary7(&self) -> crate::Result<Vec<crate::Input>> {
        let dynamic_offset = (7 * self.op.get_attr_int("NumTables")? + 7) as i32;
        let mut Inputs = vec![];
        for i in dynamic_offset..dynamic_offset + self.op.get_attr_int("NumTables")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
}
impl From<LoadAllTPUEmbeddingParametersInst> for crate::Operation {
    fn from(inst: LoadAllTPUEmbeddingParametersInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `LoadAllTPUEmbeddingParameters::new().build(parameters, auxiliary1, auxiliary2, auxiliary3, auxiliary4, auxiliary5, auxiliary6, auxiliary7, scope)`.
pub fn load_all_tpuembedding_parameters<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
    O6: ::std::convert::Into<crate::Output>,
    O7: ::std::convert::Into<crate::Output>,
>(
    parameters: O0,
    auxiliary1: O1,
    auxiliary2: O2,
    auxiliary3: O3,
    auxiliary4: O4,
    auxiliary5: O5,
    auxiliary6: O6,
    auxiliary7: O7,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    LoadAllTPUEmbeddingParameters::new().build(
        parameters, auxiliary1, auxiliary2, auxiliary3, auxiliary4, auxiliary5, auxiliary6,
        auxiliary7, scope,
    )
}

/// Builder for the `LoadAndRemapMatrix` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct LoadAndRemapMatrix {
    num_rows: ::std::option::Option<i64>,
    num_cols: ::std::option::Option<i64>,
    max_rows_in_memory: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'LoadAndRemapMatrix' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct LoadAndRemapMatrixInst {
    /// An instance of a fully built LoadAndRemapMatrix Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl LoadAndRemapMatrix {
    /// Creates a new `LoadAndRemapMatrix`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `num_rows` attribute.
    pub fn num_rows<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.num_rows = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `num_cols` attribute.
    pub fn num_cols<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.num_cols = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `max_rows_in_memory` attribute.
    pub fn max_rows_in_memory<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.max_rows_in_memory = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `LoadAndRemapMatrix` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
    >(
        &self,
        ckpt_path: O0,
        old_tensor_name: O1,
        row_remapping: O2,
        col_remapping: O3,
        initializing_values: O4,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            ckpt_path.into(),
            old_tensor_name.into(),
            row_remapping.into(),
            col_remapping.into(),
            initializing_values.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        ckpt_path: crate::Output,
        old_tensor_name: crate::Output,
        row_remapping: crate::Output,
        col_remapping: crate::Output,
        initializing_values: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("LoadAndRemapMatrix", |nd| {
            nd.add_input(ckpt_path);
            nd.add_input(old_tensor_name);
            nd.add_input(row_remapping);
            nd.add_input(col_remapping);
            nd.add_input(initializing_values);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.num_rows {
                nd.set_attr_int("num_rows", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_cols {
                nd.set_attr_int("num_cols", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.max_rows_in_memory {
                nd.set_attr_int("max_rows_in_memory", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'LoadAndRemapMatrix' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        ckpt_path: crate::Output,
        old_tensor_name: crate::Output,
        row_remapping: crate::Output,
        col_remapping: crate::Output,
        initializing_values: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<LoadAndRemapMatrixInst> {
        let op = scope.new_operation("LoadAndRemapMatrix", |builder| {
            builder.add_input(ckpt_path);
            builder.add_input(old_tensor_name);
            builder.add_input(row_remapping);
            builder.add_input(col_remapping);
            builder.add_input(initializing_values);
            if let ::std::option::Option::Some(value) = &self.num_rows {
                builder.set_attr_int("num_rows", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_cols {
                builder.set_attr_int("num_cols", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.max_rows_in_memory {
                builder.set_attr_int("max_rows_in_memory", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(LoadAndRemapMatrixInst { op })
    }
}
impl LoadAndRemapMatrixInst {
    /// Returns the 'output_matrix' Output of this 'LoadAndRemapMatrix' operation.
    pub fn output_matrix(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'ckpt_path' Input of this 'LoadAndRemapMatrix' operation.
    pub fn ckpt_path(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'old_tensor_name' Input of this 'LoadAndRemapMatrix' operation.
    pub fn old_tensor_name(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'row_remapping' Input of this 'LoadAndRemapMatrix' operation.
    pub fn row_remapping(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'col_remapping' Input of this 'LoadAndRemapMatrix' operation.
    pub fn col_remapping(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'initializing_values' Input of this 'LoadAndRemapMatrix' operation.
    pub fn initializing_values(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
}
impl From<LoadAndRemapMatrixInst> for crate::Operation {
    fn from(inst: LoadAndRemapMatrixInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `LoadAndRemapMatrix::new().build(ckpt_path, old_tensor_name, row_remapping, col_remapping, initializing_values, scope)`.
pub fn load_and_remap_matrix<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
>(
    ckpt_path: O0,
    old_tensor_name: O1,
    row_remapping: O2,
    col_remapping: O3,
    initializing_values: O4,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    LoadAndRemapMatrix::new().build(
        ckpt_path,
        old_tensor_name,
        row_remapping,
        col_remapping,
        initializing_values,
        scope,
    )
}

/// Builder for the `LoadDataset` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct LoadDataset {
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    compression: ::std::option::Option<::std::string::String>,
    reader_func: ::std::option::Option<::std::string::String>,
    Treader_func_args: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'LoadDataset' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct LoadDatasetInst {
    /// An instance of a fully built LoadDataset Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl LoadDataset {
    /// Creates a new `LoadDataset`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `compression` attribute.
    pub fn compression<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.compression = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `reader_func` attribute.
    pub fn reader_func<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.reader_func = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Treader_func_args` attribute.
    pub fn Treader_func_args<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Treader_func_args = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `LoadDataset` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        path: O0,
        reader_func_other_args: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(path.into(), reader_func_other_args.into(), scope)
    }
    fn build_impl(
        &self,
        path: crate::Output,
        reader_func_other_args: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("LoadDataset", |nd| {
            nd.add_input(path);
            nd.add_input(reader_func_other_args);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.compression {
                nd.set_attr_string("compression", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.reader_func {
                nd.set_attr_string("reader_func", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Treader_func_args {
                nd.set_attr_type_list("Treader_func_args", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'LoadDataset' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        path: crate::Output,
        reader_func_other_args: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<LoadDatasetInst> {
        let op = scope.new_operation("LoadDataset", |builder| {
            builder.add_input(path);
            builder.add_input(reader_func_other_args);
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.compression {
                builder.set_attr_string("compression", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.reader_func {
                builder.set_attr_string("reader_func", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Treader_func_args {
                builder.set_attr_type_list("Treader_func_args", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(LoadDatasetInst { op })
    }
}
impl LoadDatasetInst {
    /// Returns the 'handle' Output of this 'LoadDataset' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'path' Input of this 'LoadDataset' operation.
    pub fn path(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'reader_func_other_args' Input of this 'LoadDataset' operation.
    pub fn reader_func_other_args(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<LoadDatasetInst> for crate::Operation {
    fn from(inst: LoadDatasetInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `LoadDataset::new().build(path, reader_func_other_args, scope)`.
pub fn load_dataset<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    path: O0,
    reader_func_other_args: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    LoadDataset::new().build(path, reader_func_other_args, scope)
}

/// Builder for the `LoadTPUEmbeddingADAMParameters` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct LoadTPUEmbeddingADAMParameters {
    table_id: ::std::option::Option<i64>,
    table_name: ::std::option::Option<::std::string::String>,
    num_shards: ::std::option::Option<i64>,
    shard_id: ::std::option::Option<i64>,
    config: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'LoadTPUEmbeddingADAMParameters' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct LoadTPUEmbeddingADAMParametersInst {
    /// An instance of a fully built LoadTPUEmbeddingADAMParameters Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl LoadTPUEmbeddingADAMParameters {
    /// Creates a new `LoadTPUEmbeddingADAMParameters`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `table_id` attribute.
    pub fn table_id<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.table_id = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `table_name` attribute.
    pub fn table_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.table_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `num_shards` attribute.
    pub fn num_shards<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.num_shards = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shard_id` attribute.
    pub fn shard_id<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.shard_id = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `config` attribute.
    pub fn config<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.config = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `LoadTPUEmbeddingADAMParameters` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        parameters: O0,
        momenta: O1,
        velocities: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(parameters.into(), momenta.into(), velocities.into(), scope)
    }
    fn build_impl(
        &self,
        parameters: crate::Output,
        momenta: crate::Output,
        velocities: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("LoadTPUEmbeddingADAMParameters", |nd| {
            nd.add_input(parameters);
            nd.add_input(momenta);
            nd.add_input(velocities);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.table_id {
                nd.set_attr_int("table_id", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.table_name {
                nd.set_attr_string("table_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_shards {
                nd.set_attr_int("num_shards", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shard_id {
                nd.set_attr_int("shard_id", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.config {
                nd.set_attr_string("config", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'LoadTPUEmbeddingADAMParameters' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        parameters: crate::Output,
        momenta: crate::Output,
        velocities: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<LoadTPUEmbeddingADAMParametersInst> {
        let op = scope.new_operation("LoadTPUEmbeddingADAMParameters", |builder| {
            builder.add_input(parameters);
            builder.add_input(momenta);
            builder.add_input(velocities);
            if let ::std::option::Option::Some(value) = &self.table_id {
                builder.set_attr_int("table_id", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.table_name {
                builder.set_attr_string("table_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_shards {
                builder.set_attr_int("num_shards", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shard_id {
                builder.set_attr_int("shard_id", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.config {
                builder.set_attr_string("config", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(LoadTPUEmbeddingADAMParametersInst { op })
    }
}
impl LoadTPUEmbeddingADAMParametersInst {
    /// Returns the 'parameters' Input of this 'LoadTPUEmbeddingADAMParameters' operation.
    pub fn parameters(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'momenta' Input of this 'LoadTPUEmbeddingADAMParameters' operation.
    pub fn momenta(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'velocities' Input of this 'LoadTPUEmbeddingADAMParameters' operation.
    pub fn velocities(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<LoadTPUEmbeddingADAMParametersInst> for crate::Operation {
    fn from(inst: LoadTPUEmbeddingADAMParametersInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `LoadTPUEmbeddingADAMParameters::new().build(parameters, momenta, velocities, scope)`.
pub fn load_tpuembedding_adamparameters<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    parameters: O0,
    momenta: O1,
    velocities: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    LoadTPUEmbeddingADAMParameters::new().build(parameters, momenta, velocities, scope)
}

/// Builder for the `LoadTPUEmbeddingAdadeltaParameters` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct LoadTPUEmbeddingAdadeltaParameters {
    table_id: ::std::option::Option<i64>,
    table_name: ::std::option::Option<::std::string::String>,
    num_shards: ::std::option::Option<i64>,
    shard_id: ::std::option::Option<i64>,
    config: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'LoadTPUEmbeddingAdadeltaParameters' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct LoadTPUEmbeddingAdadeltaParametersInst {
    /// An instance of a fully built LoadTPUEmbeddingAdadeltaParameters Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl LoadTPUEmbeddingAdadeltaParameters {
    /// Creates a new `LoadTPUEmbeddingAdadeltaParameters`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `table_id` attribute.
    pub fn table_id<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.table_id = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `table_name` attribute.
    pub fn table_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.table_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `num_shards` attribute.
    pub fn num_shards<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.num_shards = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shard_id` attribute.
    pub fn shard_id<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.shard_id = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `config` attribute.
    pub fn config<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.config = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `LoadTPUEmbeddingAdadeltaParameters` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        parameters: O0,
        accumulators: O1,
        updates: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            parameters.into(),
            accumulators.into(),
            updates.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        parameters: crate::Output,
        accumulators: crate::Output,
        updates: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("LoadTPUEmbeddingAdadeltaParameters", |nd| {
            nd.add_input(parameters);
            nd.add_input(accumulators);
            nd.add_input(updates);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.table_id {
                nd.set_attr_int("table_id", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.table_name {
                nd.set_attr_string("table_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_shards {
                nd.set_attr_int("num_shards", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shard_id {
                nd.set_attr_int("shard_id", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.config {
                nd.set_attr_string("config", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'LoadTPUEmbeddingAdadeltaParameters' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        parameters: crate::Output,
        accumulators: crate::Output,
        updates: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<LoadTPUEmbeddingAdadeltaParametersInst> {
        let op = scope.new_operation("LoadTPUEmbeddingAdadeltaParameters", |builder| {
            builder.add_input(parameters);
            builder.add_input(accumulators);
            builder.add_input(updates);
            if let ::std::option::Option::Some(value) = &self.table_id {
                builder.set_attr_int("table_id", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.table_name {
                builder.set_attr_string("table_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_shards {
                builder.set_attr_int("num_shards", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shard_id {
                builder.set_attr_int("shard_id", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.config {
                builder.set_attr_string("config", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(LoadTPUEmbeddingAdadeltaParametersInst { op })
    }
}
impl LoadTPUEmbeddingAdadeltaParametersInst {
    /// Returns the 'parameters' Input of this 'LoadTPUEmbeddingAdadeltaParameters' operation.
    pub fn parameters(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'accumulators' Input of this 'LoadTPUEmbeddingAdadeltaParameters' operation.
    pub fn accumulators(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'updates' Input of this 'LoadTPUEmbeddingAdadeltaParameters' operation.
    pub fn updates(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<LoadTPUEmbeddingAdadeltaParametersInst> for crate::Operation {
    fn from(inst: LoadTPUEmbeddingAdadeltaParametersInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `LoadTPUEmbeddingAdadeltaParameters::new().build(parameters, accumulators, updates, scope)`.
pub fn load_tpuembedding_adadelta_parameters<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    parameters: O0,
    accumulators: O1,
    updates: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    LoadTPUEmbeddingAdadeltaParameters::new().build(parameters, accumulators, updates, scope)
}

/// Builder for the `LoadTPUEmbeddingAdagradMomentumParameters` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct LoadTPUEmbeddingAdagradMomentumParameters {
    table_id: ::std::option::Option<i64>,
    table_name: ::std::option::Option<::std::string::String>,
    num_shards: ::std::option::Option<i64>,
    shard_id: ::std::option::Option<i64>,
    config: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'LoadTPUEmbeddingAdagradMomentumParameters' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct LoadTPUEmbeddingAdagradMomentumParametersInst {
    /// An instance of a fully built LoadTPUEmbeddingAdagradMomentumParameters Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl LoadTPUEmbeddingAdagradMomentumParameters {
    /// Creates a new `LoadTPUEmbeddingAdagradMomentumParameters`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `table_id` attribute.
    pub fn table_id<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.table_id = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `table_name` attribute.
    pub fn table_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.table_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `num_shards` attribute.
    pub fn num_shards<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.num_shards = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shard_id` attribute.
    pub fn shard_id<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.shard_id = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `config` attribute.
    pub fn config<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.config = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `LoadTPUEmbeddingAdagradMomentumParameters` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        parameters: O0,
        accumulators: O1,
        momenta: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            parameters.into(),
            accumulators.into(),
            momenta.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        parameters: crate::Output,
        accumulators: crate::Output,
        momenta: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("LoadTPUEmbeddingAdagradMomentumParameters", |nd| {
            nd.add_input(parameters);
            nd.add_input(accumulators);
            nd.add_input(momenta);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.table_id {
                nd.set_attr_int("table_id", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.table_name {
                nd.set_attr_string("table_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_shards {
                nd.set_attr_int("num_shards", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shard_id {
                nd.set_attr_int("shard_id", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.config {
                nd.set_attr_string("config", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'LoadTPUEmbeddingAdagradMomentumParameters' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        parameters: crate::Output,
        accumulators: crate::Output,
        momenta: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<LoadTPUEmbeddingAdagradMomentumParametersInst> {
        let op = scope.new_operation("LoadTPUEmbeddingAdagradMomentumParameters", |builder| {
            builder.add_input(parameters);
            builder.add_input(accumulators);
            builder.add_input(momenta);
            if let ::std::option::Option::Some(value) = &self.table_id {
                builder.set_attr_int("table_id", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.table_name {
                builder.set_attr_string("table_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_shards {
                builder.set_attr_int("num_shards", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shard_id {
                builder.set_attr_int("shard_id", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.config {
                builder.set_attr_string("config", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(LoadTPUEmbeddingAdagradMomentumParametersInst { op })
    }
}
impl LoadTPUEmbeddingAdagradMomentumParametersInst {
    /// Returns the 'parameters' Input of this 'LoadTPUEmbeddingAdagradMomentumParameters' operation.
    pub fn parameters(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'accumulators' Input of this 'LoadTPUEmbeddingAdagradMomentumParameters' operation.
    pub fn accumulators(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'momenta' Input of this 'LoadTPUEmbeddingAdagradMomentumParameters' operation.
    pub fn momenta(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<LoadTPUEmbeddingAdagradMomentumParametersInst> for crate::Operation {
    fn from(inst: LoadTPUEmbeddingAdagradMomentumParametersInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `LoadTPUEmbeddingAdagradMomentumParameters::new().build(parameters, accumulators, momenta, scope)`.
pub fn load_tpuembedding_adagrad_momentum_parameters<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    parameters: O0,
    accumulators: O1,
    momenta: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    LoadTPUEmbeddingAdagradMomentumParameters::new().build(parameters, accumulators, momenta, scope)
}

/// Builder for the `LoadTPUEmbeddingAdagradParameters` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct LoadTPUEmbeddingAdagradParameters {
    table_id: ::std::option::Option<i64>,
    table_name: ::std::option::Option<::std::string::String>,
    num_shards: ::std::option::Option<i64>,
    shard_id: ::std::option::Option<i64>,
    config: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'LoadTPUEmbeddingAdagradParameters' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct LoadTPUEmbeddingAdagradParametersInst {
    /// An instance of a fully built LoadTPUEmbeddingAdagradParameters Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl LoadTPUEmbeddingAdagradParameters {
    /// Creates a new `LoadTPUEmbeddingAdagradParameters`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `table_id` attribute.
    pub fn table_id<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.table_id = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `table_name` attribute.
    pub fn table_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.table_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `num_shards` attribute.
    pub fn num_shards<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.num_shards = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shard_id` attribute.
    pub fn shard_id<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.shard_id = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `config` attribute.
    pub fn config<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.config = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `LoadTPUEmbeddingAdagradParameters` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        parameters: O0,
        accumulators: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(parameters.into(), accumulators.into(), scope)
    }
    fn build_impl(
        &self,
        parameters: crate::Output,
        accumulators: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("LoadTPUEmbeddingAdagradParameters", |nd| {
            nd.add_input(parameters);
            nd.add_input(accumulators);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.table_id {
                nd.set_attr_int("table_id", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.table_name {
                nd.set_attr_string("table_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_shards {
                nd.set_attr_int("num_shards", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shard_id {
                nd.set_attr_int("shard_id", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.config {
                nd.set_attr_string("config", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'LoadTPUEmbeddingAdagradParameters' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        parameters: crate::Output,
        accumulators: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<LoadTPUEmbeddingAdagradParametersInst> {
        let op = scope.new_operation("LoadTPUEmbeddingAdagradParameters", |builder| {
            builder.add_input(parameters);
            builder.add_input(accumulators);
            if let ::std::option::Option::Some(value) = &self.table_id {
                builder.set_attr_int("table_id", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.table_name {
                builder.set_attr_string("table_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_shards {
                builder.set_attr_int("num_shards", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shard_id {
                builder.set_attr_int("shard_id", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.config {
                builder.set_attr_string("config", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(LoadTPUEmbeddingAdagradParametersInst { op })
    }
}
impl LoadTPUEmbeddingAdagradParametersInst {
    /// Returns the 'parameters' Input of this 'LoadTPUEmbeddingAdagradParameters' operation.
    pub fn parameters(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'accumulators' Input of this 'LoadTPUEmbeddingAdagradParameters' operation.
    pub fn accumulators(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<LoadTPUEmbeddingAdagradParametersInst> for crate::Operation {
    fn from(inst: LoadTPUEmbeddingAdagradParametersInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `LoadTPUEmbeddingAdagradParameters::new().build(parameters, accumulators, scope)`.
pub fn load_tpuembedding_adagrad_parameters<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    parameters: O0,
    accumulators: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    LoadTPUEmbeddingAdagradParameters::new().build(parameters, accumulators, scope)
}

/// Builder for the `LoadTPUEmbeddingCenteredRMSPropParameters` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct LoadTPUEmbeddingCenteredRMSPropParameters {
    table_id: ::std::option::Option<i64>,
    table_name: ::std::option::Option<::std::string::String>,
    num_shards: ::std::option::Option<i64>,
    shard_id: ::std::option::Option<i64>,
    config: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'LoadTPUEmbeddingCenteredRMSPropParameters' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct LoadTPUEmbeddingCenteredRMSPropParametersInst {
    /// An instance of a fully built LoadTPUEmbeddingCenteredRMSPropParameters Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl LoadTPUEmbeddingCenteredRMSPropParameters {
    /// Creates a new `LoadTPUEmbeddingCenteredRMSPropParameters`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `table_id` attribute.
    pub fn table_id<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.table_id = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `table_name` attribute.
    pub fn table_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.table_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `num_shards` attribute.
    pub fn num_shards<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.num_shards = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shard_id` attribute.
    pub fn shard_id<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.shard_id = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `config` attribute.
    pub fn config<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.config = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `LoadTPUEmbeddingCenteredRMSPropParameters` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
    >(
        &self,
        parameters: O0,
        ms: O1,
        mom: O2,
        mg: O3,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(parameters.into(), ms.into(), mom.into(), mg.into(), scope)
    }
    fn build_impl(
        &self,
        parameters: crate::Output,
        ms: crate::Output,
        mom: crate::Output,
        mg: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("LoadTPUEmbeddingCenteredRMSPropParameters", |nd| {
            nd.add_input(parameters);
            nd.add_input(ms);
            nd.add_input(mom);
            nd.add_input(mg);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.table_id {
                nd.set_attr_int("table_id", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.table_name {
                nd.set_attr_string("table_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_shards {
                nd.set_attr_int("num_shards", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shard_id {
                nd.set_attr_int("shard_id", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.config {
                nd.set_attr_string("config", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'LoadTPUEmbeddingCenteredRMSPropParameters' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        parameters: crate::Output,
        ms: crate::Output,
        mom: crate::Output,
        mg: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<LoadTPUEmbeddingCenteredRMSPropParametersInst> {
        let op = scope.new_operation("LoadTPUEmbeddingCenteredRMSPropParameters", |builder| {
            builder.add_input(parameters);
            builder.add_input(ms);
            builder.add_input(mom);
            builder.add_input(mg);
            if let ::std::option::Option::Some(value) = &self.table_id {
                builder.set_attr_int("table_id", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.table_name {
                builder.set_attr_string("table_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_shards {
                builder.set_attr_int("num_shards", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shard_id {
                builder.set_attr_int("shard_id", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.config {
                builder.set_attr_string("config", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(LoadTPUEmbeddingCenteredRMSPropParametersInst { op })
    }
}
impl LoadTPUEmbeddingCenteredRMSPropParametersInst {
    /// Returns the 'parameters' Input of this 'LoadTPUEmbeddingCenteredRMSPropParameters' operation.
    pub fn parameters(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'ms' Input of this 'LoadTPUEmbeddingCenteredRMSPropParameters' operation.
    pub fn ms(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'mom' Input of this 'LoadTPUEmbeddingCenteredRMSPropParameters' operation.
    pub fn mom(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'mg' Input of this 'LoadTPUEmbeddingCenteredRMSPropParameters' operation.
    pub fn mg(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
}
impl From<LoadTPUEmbeddingCenteredRMSPropParametersInst> for crate::Operation {
    fn from(inst: LoadTPUEmbeddingCenteredRMSPropParametersInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `LoadTPUEmbeddingCenteredRMSPropParameters::new().build(parameters, ms, mom, mg, scope)`.
pub fn load_tpuembedding_centered_rmsprop_parameters<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
>(
    parameters: O0,
    ms: O1,
    mom: O2,
    mg: O3,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    LoadTPUEmbeddingCenteredRMSPropParameters::new().build(parameters, ms, mom, mg, scope)
}

/// Builder for the `LoadTPUEmbeddingFTRLParameters` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct LoadTPUEmbeddingFTRLParameters {
    table_id: ::std::option::Option<i64>,
    table_name: ::std::option::Option<::std::string::String>,
    num_shards: ::std::option::Option<i64>,
    shard_id: ::std::option::Option<i64>,
    config: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'LoadTPUEmbeddingFTRLParameters' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct LoadTPUEmbeddingFTRLParametersInst {
    /// An instance of a fully built LoadTPUEmbeddingFTRLParameters Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl LoadTPUEmbeddingFTRLParameters {
    /// Creates a new `LoadTPUEmbeddingFTRLParameters`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `table_id` attribute.
    pub fn table_id<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.table_id = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `table_name` attribute.
    pub fn table_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.table_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `num_shards` attribute.
    pub fn num_shards<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.num_shards = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shard_id` attribute.
    pub fn shard_id<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.shard_id = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `config` attribute.
    pub fn config<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.config = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `LoadTPUEmbeddingFTRLParameters` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        parameters: O0,
        accumulators: O1,
        linears: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            parameters.into(),
            accumulators.into(),
            linears.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        parameters: crate::Output,
        accumulators: crate::Output,
        linears: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("LoadTPUEmbeddingFTRLParameters", |nd| {
            nd.add_input(parameters);
            nd.add_input(accumulators);
            nd.add_input(linears);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.table_id {
                nd.set_attr_int("table_id", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.table_name {
                nd.set_attr_string("table_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_shards {
                nd.set_attr_int("num_shards", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shard_id {
                nd.set_attr_int("shard_id", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.config {
                nd.set_attr_string("config", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'LoadTPUEmbeddingFTRLParameters' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        parameters: crate::Output,
        accumulators: crate::Output,
        linears: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<LoadTPUEmbeddingFTRLParametersInst> {
        let op = scope.new_operation("LoadTPUEmbeddingFTRLParameters", |builder| {
            builder.add_input(parameters);
            builder.add_input(accumulators);
            builder.add_input(linears);
            if let ::std::option::Option::Some(value) = &self.table_id {
                builder.set_attr_int("table_id", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.table_name {
                builder.set_attr_string("table_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_shards {
                builder.set_attr_int("num_shards", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shard_id {
                builder.set_attr_int("shard_id", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.config {
                builder.set_attr_string("config", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(LoadTPUEmbeddingFTRLParametersInst { op })
    }
}
impl LoadTPUEmbeddingFTRLParametersInst {
    /// Returns the 'parameters' Input of this 'LoadTPUEmbeddingFTRLParameters' operation.
    pub fn parameters(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'accumulators' Input of this 'LoadTPUEmbeddingFTRLParameters' operation.
    pub fn accumulators(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'linears' Input of this 'LoadTPUEmbeddingFTRLParameters' operation.
    pub fn linears(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<LoadTPUEmbeddingFTRLParametersInst> for crate::Operation {
    fn from(inst: LoadTPUEmbeddingFTRLParametersInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `LoadTPUEmbeddingFTRLParameters::new().build(parameters, accumulators, linears, scope)`.
pub fn load_tpuembedding_ftrlparameters<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    parameters: O0,
    accumulators: O1,
    linears: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    LoadTPUEmbeddingFTRLParameters::new().build(parameters, accumulators, linears, scope)
}

/// Builder for the `LoadTPUEmbeddingFrequencyEstimatorParameters` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct LoadTPUEmbeddingFrequencyEstimatorParameters {
    table_id: ::std::option::Option<i64>,
    table_name: ::std::option::Option<::std::string::String>,
    num_shards: ::std::option::Option<i64>,
    shard_id: ::std::option::Option<i64>,
    config: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'LoadTPUEmbeddingFrequencyEstimatorParameters' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct LoadTPUEmbeddingFrequencyEstimatorParametersInst {
    /// An instance of a fully built LoadTPUEmbeddingFrequencyEstimatorParameters Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl LoadTPUEmbeddingFrequencyEstimatorParameters {
    /// Creates a new `LoadTPUEmbeddingFrequencyEstimatorParameters`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `table_id` attribute.
    pub fn table_id<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.table_id = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `table_name` attribute.
    pub fn table_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.table_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `num_shards` attribute.
    pub fn num_shards<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.num_shards = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shard_id` attribute.
    pub fn shard_id<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.shard_id = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `config` attribute.
    pub fn config<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.config = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `LoadTPUEmbeddingFrequencyEstimatorParameters` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        parameters: O0,
        last_hit_step: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(parameters.into(), last_hit_step.into(), scope)
    }
    fn build_impl(
        &self,
        parameters: crate::Output,
        last_hit_step: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("LoadTPUEmbeddingFrequencyEstimatorParameters", |nd| {
            nd.add_input(parameters);
            nd.add_input(last_hit_step);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.table_id {
                nd.set_attr_int("table_id", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.table_name {
                nd.set_attr_string("table_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_shards {
                nd.set_attr_int("num_shards", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shard_id {
                nd.set_attr_int("shard_id", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.config {
                nd.set_attr_string("config", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'LoadTPUEmbeddingFrequencyEstimatorParameters' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        parameters: crate::Output,
        last_hit_step: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<LoadTPUEmbeddingFrequencyEstimatorParametersInst> {
        let op =
            scope.new_operation("LoadTPUEmbeddingFrequencyEstimatorParameters", |builder| {
                builder.add_input(parameters);
                builder.add_input(last_hit_step);
                if let ::std::option::Option::Some(value) = &self.table_id {
                    builder.set_attr_int("table_id", *value)?;
                }
                if let ::std::option::Option::Some(value) = &self.table_name {
                    builder.set_attr_string("table_name", value)?;
                }
                if let ::std::option::Option::Some(value) = &self.num_shards {
                    builder.set_attr_int("num_shards", *value)?;
                }
                if let ::std::option::Option::Some(value) = &self.shard_id {
                    builder.set_attr_int("shard_id", *value)?;
                }
                if let ::std::option::Option::Some(value) = &self.config {
                    builder.set_attr_string("config", value)?;
                }
                ::std::result::Result::Ok(())
            })?;
        Ok(LoadTPUEmbeddingFrequencyEstimatorParametersInst { op })
    }
}
impl LoadTPUEmbeddingFrequencyEstimatorParametersInst {
    /// Returns the 'parameters' Input of this 'LoadTPUEmbeddingFrequencyEstimatorParameters' operation.
    pub fn parameters(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'last_hit_step' Input of this 'LoadTPUEmbeddingFrequencyEstimatorParameters' operation.
    pub fn last_hit_step(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<LoadTPUEmbeddingFrequencyEstimatorParametersInst> for crate::Operation {
    fn from(inst: LoadTPUEmbeddingFrequencyEstimatorParametersInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `LoadTPUEmbeddingFrequencyEstimatorParameters::new().build(parameters, last_hit_step, scope)`.
pub fn load_tpuembedding_frequency_estimator_parameters<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    parameters: O0,
    last_hit_step: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    LoadTPUEmbeddingFrequencyEstimatorParameters::new().build(parameters, last_hit_step, scope)
}

/// Builder for the `LoadTPUEmbeddingMDLAdagradLightParameters` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct LoadTPUEmbeddingMDLAdagradLightParameters {
    table_id: ::std::option::Option<i64>,
    table_name: ::std::option::Option<::std::string::String>,
    num_shards: ::std::option::Option<i64>,
    shard_id: ::std::option::Option<i64>,
    config: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'LoadTPUEmbeddingMDLAdagradLightParameters' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct LoadTPUEmbeddingMDLAdagradLightParametersInst {
    /// An instance of a fully built LoadTPUEmbeddingMDLAdagradLightParameters Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl LoadTPUEmbeddingMDLAdagradLightParameters {
    /// Creates a new `LoadTPUEmbeddingMDLAdagradLightParameters`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `table_id` attribute.
    pub fn table_id<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.table_id = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `table_name` attribute.
    pub fn table_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.table_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `num_shards` attribute.
    pub fn num_shards<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.num_shards = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shard_id` attribute.
    pub fn shard_id<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.shard_id = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `config` attribute.
    pub fn config<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.config = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `LoadTPUEmbeddingMDLAdagradLightParameters` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
    >(
        &self,
        parameters: O0,
        accumulators: O1,
        weights: O2,
        benefits: O3,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            parameters.into(),
            accumulators.into(),
            weights.into(),
            benefits.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        parameters: crate::Output,
        accumulators: crate::Output,
        weights: crate::Output,
        benefits: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("LoadTPUEmbeddingMDLAdagradLightParameters", |nd| {
            nd.add_input(parameters);
            nd.add_input(accumulators);
            nd.add_input(weights);
            nd.add_input(benefits);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.table_id {
                nd.set_attr_int("table_id", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.table_name {
                nd.set_attr_string("table_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_shards {
                nd.set_attr_int("num_shards", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shard_id {
                nd.set_attr_int("shard_id", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.config {
                nd.set_attr_string("config", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'LoadTPUEmbeddingMDLAdagradLightParameters' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        parameters: crate::Output,
        accumulators: crate::Output,
        weights: crate::Output,
        benefits: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<LoadTPUEmbeddingMDLAdagradLightParametersInst> {
        let op = scope.new_operation("LoadTPUEmbeddingMDLAdagradLightParameters", |builder| {
            builder.add_input(parameters);
            builder.add_input(accumulators);
            builder.add_input(weights);
            builder.add_input(benefits);
            if let ::std::option::Option::Some(value) = &self.table_id {
                builder.set_attr_int("table_id", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.table_name {
                builder.set_attr_string("table_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_shards {
                builder.set_attr_int("num_shards", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shard_id {
                builder.set_attr_int("shard_id", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.config {
                builder.set_attr_string("config", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(LoadTPUEmbeddingMDLAdagradLightParametersInst { op })
    }
}
impl LoadTPUEmbeddingMDLAdagradLightParametersInst {
    /// Returns the 'parameters' Input of this 'LoadTPUEmbeddingMDLAdagradLightParameters' operation.
    pub fn parameters(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'accumulators' Input of this 'LoadTPUEmbeddingMDLAdagradLightParameters' operation.
    pub fn accumulators(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'weights' Input of this 'LoadTPUEmbeddingMDLAdagradLightParameters' operation.
    pub fn weights(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'benefits' Input of this 'LoadTPUEmbeddingMDLAdagradLightParameters' operation.
    pub fn benefits(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
}
impl From<LoadTPUEmbeddingMDLAdagradLightParametersInst> for crate::Operation {
    fn from(inst: LoadTPUEmbeddingMDLAdagradLightParametersInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `LoadTPUEmbeddingMDLAdagradLightParameters::new().build(parameters, accumulators, weights, benefits, scope)`.
pub fn load_tpuembedding_mdladagrad_light_parameters<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
>(
    parameters: O0,
    accumulators: O1,
    weights: O2,
    benefits: O3,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    LoadTPUEmbeddingMDLAdagradLightParameters::new().build(
        parameters,
        accumulators,
        weights,
        benefits,
        scope,
    )
}

/// Builder for the `LoadTPUEmbeddingMomentumParameters` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct LoadTPUEmbeddingMomentumParameters {
    table_id: ::std::option::Option<i64>,
    table_name: ::std::option::Option<::std::string::String>,
    num_shards: ::std::option::Option<i64>,
    shard_id: ::std::option::Option<i64>,
    config: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'LoadTPUEmbeddingMomentumParameters' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct LoadTPUEmbeddingMomentumParametersInst {
    /// An instance of a fully built LoadTPUEmbeddingMomentumParameters Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl LoadTPUEmbeddingMomentumParameters {
    /// Creates a new `LoadTPUEmbeddingMomentumParameters`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `table_id` attribute.
    pub fn table_id<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.table_id = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `table_name` attribute.
    pub fn table_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.table_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `num_shards` attribute.
    pub fn num_shards<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.num_shards = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shard_id` attribute.
    pub fn shard_id<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.shard_id = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `config` attribute.
    pub fn config<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.config = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `LoadTPUEmbeddingMomentumParameters` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        parameters: O0,
        momenta: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(parameters.into(), momenta.into(), scope)
    }
    fn build_impl(
        &self,
        parameters: crate::Output,
        momenta: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("LoadTPUEmbeddingMomentumParameters", |nd| {
            nd.add_input(parameters);
            nd.add_input(momenta);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.table_id {
                nd.set_attr_int("table_id", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.table_name {
                nd.set_attr_string("table_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_shards {
                nd.set_attr_int("num_shards", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shard_id {
                nd.set_attr_int("shard_id", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.config {
                nd.set_attr_string("config", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'LoadTPUEmbeddingMomentumParameters' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        parameters: crate::Output,
        momenta: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<LoadTPUEmbeddingMomentumParametersInst> {
        let op = scope.new_operation("LoadTPUEmbeddingMomentumParameters", |builder| {
            builder.add_input(parameters);
            builder.add_input(momenta);
            if let ::std::option::Option::Some(value) = &self.table_id {
                builder.set_attr_int("table_id", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.table_name {
                builder.set_attr_string("table_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_shards {
                builder.set_attr_int("num_shards", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shard_id {
                builder.set_attr_int("shard_id", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.config {
                builder.set_attr_string("config", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(LoadTPUEmbeddingMomentumParametersInst { op })
    }
}
impl LoadTPUEmbeddingMomentumParametersInst {
    /// Returns the 'parameters' Input of this 'LoadTPUEmbeddingMomentumParameters' operation.
    pub fn parameters(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'momenta' Input of this 'LoadTPUEmbeddingMomentumParameters' operation.
    pub fn momenta(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<LoadTPUEmbeddingMomentumParametersInst> for crate::Operation {
    fn from(inst: LoadTPUEmbeddingMomentumParametersInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `LoadTPUEmbeddingMomentumParameters::new().build(parameters, momenta, scope)`.
pub fn load_tpuembedding_momentum_parameters<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    parameters: O0,
    momenta: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    LoadTPUEmbeddingMomentumParameters::new().build(parameters, momenta, scope)
}

/// Builder for the `LoadTPUEmbeddingProximalAdagradParameters` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct LoadTPUEmbeddingProximalAdagradParameters {
    table_id: ::std::option::Option<i64>,
    table_name: ::std::option::Option<::std::string::String>,
    num_shards: ::std::option::Option<i64>,
    shard_id: ::std::option::Option<i64>,
    config: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'LoadTPUEmbeddingProximalAdagradParameters' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct LoadTPUEmbeddingProximalAdagradParametersInst {
    /// An instance of a fully built LoadTPUEmbeddingProximalAdagradParameters Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl LoadTPUEmbeddingProximalAdagradParameters {
    /// Creates a new `LoadTPUEmbeddingProximalAdagradParameters`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `table_id` attribute.
    pub fn table_id<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.table_id = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `table_name` attribute.
    pub fn table_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.table_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `num_shards` attribute.
    pub fn num_shards<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.num_shards = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shard_id` attribute.
    pub fn shard_id<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.shard_id = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `config` attribute.
    pub fn config<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.config = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `LoadTPUEmbeddingProximalAdagradParameters` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        parameters: O0,
        accumulators: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(parameters.into(), accumulators.into(), scope)
    }
    fn build_impl(
        &self,
        parameters: crate::Output,
        accumulators: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("LoadTPUEmbeddingProximalAdagradParameters", |nd| {
            nd.add_input(parameters);
            nd.add_input(accumulators);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.table_id {
                nd.set_attr_int("table_id", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.table_name {
                nd.set_attr_string("table_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_shards {
                nd.set_attr_int("num_shards", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shard_id {
                nd.set_attr_int("shard_id", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.config {
                nd.set_attr_string("config", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'LoadTPUEmbeddingProximalAdagradParameters' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        parameters: crate::Output,
        accumulators: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<LoadTPUEmbeddingProximalAdagradParametersInst> {
        let op = scope.new_operation("LoadTPUEmbeddingProximalAdagradParameters", |builder| {
            builder.add_input(parameters);
            builder.add_input(accumulators);
            if let ::std::option::Option::Some(value) = &self.table_id {
                builder.set_attr_int("table_id", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.table_name {
                builder.set_attr_string("table_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_shards {
                builder.set_attr_int("num_shards", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shard_id {
                builder.set_attr_int("shard_id", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.config {
                builder.set_attr_string("config", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(LoadTPUEmbeddingProximalAdagradParametersInst { op })
    }
}
impl LoadTPUEmbeddingProximalAdagradParametersInst {
    /// Returns the 'parameters' Input of this 'LoadTPUEmbeddingProximalAdagradParameters' operation.
    pub fn parameters(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'accumulators' Input of this 'LoadTPUEmbeddingProximalAdagradParameters' operation.
    pub fn accumulators(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<LoadTPUEmbeddingProximalAdagradParametersInst> for crate::Operation {
    fn from(inst: LoadTPUEmbeddingProximalAdagradParametersInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `LoadTPUEmbeddingProximalAdagradParameters::new().build(parameters, accumulators, scope)`.
pub fn load_tpuembedding_proximal_adagrad_parameters<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    parameters: O0,
    accumulators: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    LoadTPUEmbeddingProximalAdagradParameters::new().build(parameters, accumulators, scope)
}

/// Builder for the `LoadTPUEmbeddingProximalYogiParameters` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct LoadTPUEmbeddingProximalYogiParameters {
    table_id: ::std::option::Option<i64>,
    table_name: ::std::option::Option<::std::string::String>,
    num_shards: ::std::option::Option<i64>,
    shard_id: ::std::option::Option<i64>,
    config: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'LoadTPUEmbeddingProximalYogiParameters' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct LoadTPUEmbeddingProximalYogiParametersInst {
    /// An instance of a fully built LoadTPUEmbeddingProximalYogiParameters Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl LoadTPUEmbeddingProximalYogiParameters {
    /// Creates a new `LoadTPUEmbeddingProximalYogiParameters`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `table_id` attribute.
    pub fn table_id<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.table_id = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `table_name` attribute.
    pub fn table_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.table_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `num_shards` attribute.
    pub fn num_shards<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.num_shards = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shard_id` attribute.
    pub fn shard_id<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.shard_id = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `config` attribute.
    pub fn config<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.config = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `LoadTPUEmbeddingProximalYogiParameters` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        parameters: O0,
        v: O1,
        m: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(parameters.into(), v.into(), m.into(), scope)
    }
    fn build_impl(
        &self,
        parameters: crate::Output,
        v: crate::Output,
        m: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("LoadTPUEmbeddingProximalYogiParameters", |nd| {
            nd.add_input(parameters);
            nd.add_input(v);
            nd.add_input(m);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.table_id {
                nd.set_attr_int("table_id", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.table_name {
                nd.set_attr_string("table_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_shards {
                nd.set_attr_int("num_shards", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shard_id {
                nd.set_attr_int("shard_id", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.config {
                nd.set_attr_string("config", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'LoadTPUEmbeddingProximalYogiParameters' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        parameters: crate::Output,
        v: crate::Output,
        m: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<LoadTPUEmbeddingProximalYogiParametersInst> {
        let op = scope.new_operation("LoadTPUEmbeddingProximalYogiParameters", |builder| {
            builder.add_input(parameters);
            builder.add_input(v);
            builder.add_input(m);
            if let ::std::option::Option::Some(value) = &self.table_id {
                builder.set_attr_int("table_id", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.table_name {
                builder.set_attr_string("table_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_shards {
                builder.set_attr_int("num_shards", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shard_id {
                builder.set_attr_int("shard_id", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.config {
                builder.set_attr_string("config", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(LoadTPUEmbeddingProximalYogiParametersInst { op })
    }
}
impl LoadTPUEmbeddingProximalYogiParametersInst {
    /// Returns the 'parameters' Input of this 'LoadTPUEmbeddingProximalYogiParameters' operation.
    pub fn parameters(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'v' Input of this 'LoadTPUEmbeddingProximalYogiParameters' operation.
    pub fn v(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'm' Input of this 'LoadTPUEmbeddingProximalYogiParameters' operation.
    pub fn m(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<LoadTPUEmbeddingProximalYogiParametersInst> for crate::Operation {
    fn from(inst: LoadTPUEmbeddingProximalYogiParametersInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `LoadTPUEmbeddingProximalYogiParameters::new().build(parameters, v, m, scope)`.
pub fn load_tpuembedding_proximal_yogi_parameters<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    parameters: O0,
    v: O1,
    m: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    LoadTPUEmbeddingProximalYogiParameters::new().build(parameters, v, m, scope)
}

/// Builder for the `LoadTPUEmbeddingRMSPropParameters` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct LoadTPUEmbeddingRMSPropParameters {
    table_id: ::std::option::Option<i64>,
    table_name: ::std::option::Option<::std::string::String>,
    num_shards: ::std::option::Option<i64>,
    shard_id: ::std::option::Option<i64>,
    config: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'LoadTPUEmbeddingRMSPropParameters' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct LoadTPUEmbeddingRMSPropParametersInst {
    /// An instance of a fully built LoadTPUEmbeddingRMSPropParameters Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl LoadTPUEmbeddingRMSPropParameters {
    /// Creates a new `LoadTPUEmbeddingRMSPropParameters`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `table_id` attribute.
    pub fn table_id<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.table_id = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `table_name` attribute.
    pub fn table_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.table_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `num_shards` attribute.
    pub fn num_shards<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.num_shards = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shard_id` attribute.
    pub fn shard_id<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.shard_id = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `config` attribute.
    pub fn config<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.config = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `LoadTPUEmbeddingRMSPropParameters` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        parameters: O0,
        ms: O1,
        mom: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(parameters.into(), ms.into(), mom.into(), scope)
    }
    fn build_impl(
        &self,
        parameters: crate::Output,
        ms: crate::Output,
        mom: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("LoadTPUEmbeddingRMSPropParameters", |nd| {
            nd.add_input(parameters);
            nd.add_input(ms);
            nd.add_input(mom);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.table_id {
                nd.set_attr_int("table_id", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.table_name {
                nd.set_attr_string("table_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_shards {
                nd.set_attr_int("num_shards", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shard_id {
                nd.set_attr_int("shard_id", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.config {
                nd.set_attr_string("config", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'LoadTPUEmbeddingRMSPropParameters' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        parameters: crate::Output,
        ms: crate::Output,
        mom: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<LoadTPUEmbeddingRMSPropParametersInst> {
        let op = scope.new_operation("LoadTPUEmbeddingRMSPropParameters", |builder| {
            builder.add_input(parameters);
            builder.add_input(ms);
            builder.add_input(mom);
            if let ::std::option::Option::Some(value) = &self.table_id {
                builder.set_attr_int("table_id", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.table_name {
                builder.set_attr_string("table_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_shards {
                builder.set_attr_int("num_shards", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shard_id {
                builder.set_attr_int("shard_id", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.config {
                builder.set_attr_string("config", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(LoadTPUEmbeddingRMSPropParametersInst { op })
    }
}
impl LoadTPUEmbeddingRMSPropParametersInst {
    /// Returns the 'parameters' Input of this 'LoadTPUEmbeddingRMSPropParameters' operation.
    pub fn parameters(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'ms' Input of this 'LoadTPUEmbeddingRMSPropParameters' operation.
    pub fn ms(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'mom' Input of this 'LoadTPUEmbeddingRMSPropParameters' operation.
    pub fn mom(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<LoadTPUEmbeddingRMSPropParametersInst> for crate::Operation {
    fn from(inst: LoadTPUEmbeddingRMSPropParametersInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `LoadTPUEmbeddingRMSPropParameters::new().build(parameters, ms, mom, scope)`.
pub fn load_tpuembedding_rmsprop_parameters<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    parameters: O0,
    ms: O1,
    mom: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    LoadTPUEmbeddingRMSPropParameters::new().build(parameters, ms, mom, scope)
}

/// Builder for the `LoadTPUEmbeddingStochasticGradientDescentParameters` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct LoadTPUEmbeddingStochasticGradientDescentParameters {
    table_id: ::std::option::Option<i64>,
    table_name: ::std::option::Option<::std::string::String>,
    num_shards: ::std::option::Option<i64>,
    shard_id: ::std::option::Option<i64>,
    config: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'LoadTPUEmbeddingStochasticGradientDescentParameters' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct LoadTPUEmbeddingStochasticGradientDescentParametersInst {
    /// An instance of a fully built LoadTPUEmbeddingStochasticGradientDescentParameters Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl LoadTPUEmbeddingStochasticGradientDescentParameters {
    /// Creates a new `LoadTPUEmbeddingStochasticGradientDescentParameters`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `table_id` attribute.
    pub fn table_id<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.table_id = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `table_name` attribute.
    pub fn table_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.table_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `num_shards` attribute.
    pub fn num_shards<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.num_shards = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shard_id` attribute.
    pub fn shard_id<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.shard_id = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `config` attribute.
    pub fn config<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.config = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `LoadTPUEmbeddingStochasticGradientDescentParameters` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        parameters: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(parameters.into(), scope)
    }
    fn build_impl(
        &self,
        parameters: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation(
            "LoadTPUEmbeddingStochasticGradientDescentParameters",
            |nd| {
                nd.add_input(parameters);
                for op in &self.control_inputs {
                    nd.add_control_input(op);
                }
                if let ::std::option::Option::Some(value) = &self.table_id {
                    nd.set_attr_int("table_id", *value)?;
                }
                if let ::std::option::Option::Some(value) = &self.table_name {
                    nd.set_attr_string("table_name", value)?;
                }
                if let ::std::option::Option::Some(value) = &self.num_shards {
                    nd.set_attr_int("num_shards", *value)?;
                }
                if let ::std::option::Option::Some(value) = &self.shard_id {
                    nd.set_attr_int("shard_id", *value)?;
                }
                if let ::std::option::Option::Some(value) = &self.config {
                    nd.set_attr_string("config", value)?;
                }
                ::std::result::Result::Ok(())
            },
        )
    }

    /// Builds a new instance of 'LoadTPUEmbeddingStochasticGradientDescentParameters' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        parameters: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<LoadTPUEmbeddingStochasticGradientDescentParametersInst> {
        let op = scope.new_operation(
            "LoadTPUEmbeddingStochasticGradientDescentParameters",
            |builder| {
                builder.add_input(parameters);
                if let ::std::option::Option::Some(value) = &self.table_id {
                    builder.set_attr_int("table_id", *value)?;
                }
                if let ::std::option::Option::Some(value) = &self.table_name {
                    builder.set_attr_string("table_name", value)?;
                }
                if let ::std::option::Option::Some(value) = &self.num_shards {
                    builder.set_attr_int("num_shards", *value)?;
                }
                if let ::std::option::Option::Some(value) = &self.shard_id {
                    builder.set_attr_int("shard_id", *value)?;
                }
                if let ::std::option::Option::Some(value) = &self.config {
                    builder.set_attr_string("config", value)?;
                }
                ::std::result::Result::Ok(())
            },
        )?;
        Ok(LoadTPUEmbeddingStochasticGradientDescentParametersInst { op })
    }
}
impl LoadTPUEmbeddingStochasticGradientDescentParametersInst {
    /// Returns the 'parameters' Input of this 'LoadTPUEmbeddingStochasticGradientDescentParameters' operation.
    pub fn parameters(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<LoadTPUEmbeddingStochasticGradientDescentParametersInst> for crate::Operation {
    fn from(inst: LoadTPUEmbeddingStochasticGradientDescentParametersInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `LoadTPUEmbeddingStochasticGradientDescentParameters::new().build(parameters, scope)`.
pub fn load_tpuembedding_stochastic_gradient_descent_parameters<
    O0: ::std::convert::Into<crate::Output>,
>(
    parameters: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    LoadTPUEmbeddingStochasticGradientDescentParameters::new().build(parameters, scope)
}

/// Builder for the `Log` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Log {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Log' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct LogInst {
    /// An instance of a fully built Log Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Log {
    /// Creates a new `Log`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Log` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        x: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Log", |nd| {
            nd.add_input(x);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Log' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<LogInst> {
        let op = scope.new_operation("Log", |builder| {
            builder.add_input(x);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(LogInst { op })
    }
}
impl LogInst {
    /// Returns the 'y' Output of this 'Log' operation.
    pub fn y(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'Log' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<LogInst> for crate::Operation {
    fn from(inst: LogInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Log::new().build(x, scope)`.
pub fn log<O0: ::std::convert::Into<crate::Output>>(
    x: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Log::new().build(x, scope)
}

/// Builder for the `Log1p` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Log1p {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Log1p' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct Log1pInst {
    /// An instance of a fully built Log1p Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Log1p {
    /// Creates a new `Log1p`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Log1p` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        x: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Log1p", |nd| {
            nd.add_input(x);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Log1p' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<Log1pInst> {
        let op = scope.new_operation("Log1p", |builder| {
            builder.add_input(x);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(Log1pInst { op })
    }
}
impl Log1pInst {
    /// Returns the 'y' Output of this 'Log1p' operation.
    pub fn y(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'Log1p' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<Log1pInst> for crate::Operation {
    fn from(inst: Log1pInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Log1p::new().build(x, scope)`.
pub fn log1p<O0: ::std::convert::Into<crate::Output>>(
    x: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Log1p::new().build(x, scope)
}

/// Builder for the `LogMatrixDeterminant` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct LogMatrixDeterminant {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'LogMatrixDeterminant' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct LogMatrixDeterminantInst {
    /// An instance of a fully built LogMatrixDeterminant Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl LogMatrixDeterminant {
    /// Creates a new `LogMatrixDeterminant`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `LogMatrixDeterminant` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("LogMatrixDeterminant", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'LogMatrixDeterminant' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<LogMatrixDeterminantInst> {
        let op = scope.new_operation("LogMatrixDeterminant", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(LogMatrixDeterminantInst { op })
    }
}
impl LogMatrixDeterminantInst {
    /// Returns the 'sign' Output of this 'LogMatrixDeterminant' operation.
    pub fn sign(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'log_abs_determinant' Output of this 'LogMatrixDeterminant' operation.
    pub fn log_abs_determinant(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'input' Input of this 'LogMatrixDeterminant' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<LogMatrixDeterminantInst> for crate::Operation {
    fn from(inst: LogMatrixDeterminantInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `LogMatrixDeterminant::new().build(input, scope)`.
pub fn log_matrix_determinant<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    LogMatrixDeterminant::new().build(input, scope)
}

/// Builder for the `LogSoftmax` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct LogSoftmax {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'LogSoftmax' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct LogSoftmaxInst {
    /// An instance of a fully built LogSoftmax Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl LogSoftmax {
    /// Creates a new `LogSoftmax`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `LogSoftmax` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        logits: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(logits.into(), scope)
    }
    fn build_impl(
        &self,
        logits: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("LogSoftmax", |nd| {
            nd.add_input(logits);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'LogSoftmax' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        logits: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<LogSoftmaxInst> {
        let op = scope.new_operation("LogSoftmax", |builder| {
            builder.add_input(logits);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(LogSoftmaxInst { op })
    }
}
impl LogSoftmaxInst {
    /// Returns the 'logsoftmax' Output of this 'LogSoftmax' operation.
    pub fn logsoftmax(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'logits' Input of this 'LogSoftmax' operation.
    pub fn logits(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<LogSoftmaxInst> for crate::Operation {
    fn from(inst: LogSoftmaxInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `LogSoftmax::new().build(logits, scope)`.
pub fn log_softmax<O0: ::std::convert::Into<crate::Output>>(
    logits: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    LogSoftmax::new().build(logits, scope)
}

/// Builder for the `LogUniformCandidateSampler` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct LogUniformCandidateSampler {
    num_true: ::std::option::Option<i64>,
    num_sampled: ::std::option::Option<i64>,
    unique: ::std::option::Option<bool>,
    range_max: ::std::option::Option<i64>,
    seed: ::std::option::Option<i64>,
    seed2: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'LogUniformCandidateSampler' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct LogUniformCandidateSamplerInst {
    /// An instance of a fully built LogUniformCandidateSampler Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl LogUniformCandidateSampler {
    /// Creates a new `LogUniformCandidateSampler`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `num_true` attribute.
    pub fn num_true<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.num_true = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `num_sampled` attribute.
    pub fn num_sampled<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.num_sampled = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `unique` attribute.
    pub fn unique<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.unique = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `range_max` attribute.
    pub fn range_max<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.range_max = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `seed` attribute.
    pub fn seed<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.seed = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `seed2` attribute.
    pub fn seed2<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.seed2 = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `LogUniformCandidateSampler` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        true_classes: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(true_classes.into(), scope)
    }
    fn build_impl(
        &self,
        true_classes: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("LogUniformCandidateSampler", |nd| {
            nd.add_input(true_classes);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.num_true {
                nd.set_attr_int("num_true", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_sampled {
                nd.set_attr_int("num_sampled", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.unique {
                nd.set_attr_bool("unique", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.range_max {
                nd.set_attr_int("range_max", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed {
                nd.set_attr_int("seed", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed2 {
                nd.set_attr_int("seed2", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'LogUniformCandidateSampler' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        true_classes: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<LogUniformCandidateSamplerInst> {
        let op = scope.new_operation("LogUniformCandidateSampler", |builder| {
            builder.add_input(true_classes);
            if let ::std::option::Option::Some(value) = &self.num_true {
                builder.set_attr_int("num_true", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_sampled {
                builder.set_attr_int("num_sampled", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.unique {
                builder.set_attr_bool("unique", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.range_max {
                builder.set_attr_int("range_max", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed {
                builder.set_attr_int("seed", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed2 {
                builder.set_attr_int("seed2", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(LogUniformCandidateSamplerInst { op })
    }
}
impl LogUniformCandidateSamplerInst {
    /// Returns the 'sampled_candidates' Output of this 'LogUniformCandidateSampler' operation.
    pub fn sampled_candidates(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'true_expected_count' Output of this 'LogUniformCandidateSampler' operation.
    pub fn true_expected_count(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'sampled_expected_count' Output of this 'LogUniformCandidateSampler' operation.
    pub fn sampled_expected_count(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns the 'true_classes' Input of this 'LogUniformCandidateSampler' operation.
    pub fn true_classes(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<LogUniformCandidateSamplerInst> for crate::Operation {
    fn from(inst: LogUniformCandidateSamplerInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `LogUniformCandidateSampler::new().build(true_classes, scope)`.
pub fn log_uniform_candidate_sampler<O0: ::std::convert::Into<crate::Output>>(
    true_classes: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    LogUniformCandidateSampler::new().build(true_classes, scope)
}

/// Builder for the `LogicalAnd` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct LogicalAnd {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'LogicalAnd' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct LogicalAndInst {
    /// An instance of a fully built LogicalAnd Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl LogicalAnd {
    /// Creates a new `LogicalAnd`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `LogicalAnd` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        x: O0,
        y: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), y.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        y: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("LogicalAnd", |nd| {
            nd.add_input(x);
            nd.add_input(y);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'LogicalAnd' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        y: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<LogicalAndInst> {
        let op = scope.new_operation("LogicalAnd", |builder| {
            builder.add_input(x);
            builder.add_input(y);
            ::std::result::Result::Ok(())
        })?;
        Ok(LogicalAndInst { op })
    }
}
impl LogicalAndInst {
    /// Returns the 'z' Output of this 'LogicalAnd' operation.
    pub fn z(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'LogicalAnd' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'y' Input of this 'LogicalAnd' operation.
    pub fn y(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<LogicalAndInst> for crate::Operation {
    fn from(inst: LogicalAndInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `LogicalAnd::new().build(x, y, scope)`.
pub fn logical_and<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    x: O0,
    y: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    LogicalAnd::new().build(x, y, scope)
}

/// Builder for the `LogicalNot` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct LogicalNot {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'LogicalNot' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct LogicalNotInst {
    /// An instance of a fully built LogicalNot Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl LogicalNot {
    /// Creates a new `LogicalNot`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `LogicalNot` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        x: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("LogicalNot", |nd| {
            nd.add_input(x);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'LogicalNot' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<LogicalNotInst> {
        let op = scope.new_operation("LogicalNot", |builder| {
            builder.add_input(x);
            ::std::result::Result::Ok(())
        })?;
        Ok(LogicalNotInst { op })
    }
}
impl LogicalNotInst {
    /// Returns the 'y' Output of this 'LogicalNot' operation.
    pub fn y(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'LogicalNot' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<LogicalNotInst> for crate::Operation {
    fn from(inst: LogicalNotInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `LogicalNot::new().build(x, scope)`.
pub fn logical_not<O0: ::std::convert::Into<crate::Output>>(
    x: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    LogicalNot::new().build(x, scope)
}

/// Builder for the `LogicalOr` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct LogicalOr {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'LogicalOr' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct LogicalOrInst {
    /// An instance of a fully built LogicalOr Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl LogicalOr {
    /// Creates a new `LogicalOr`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `LogicalOr` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        x: O0,
        y: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), y.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        y: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("LogicalOr", |nd| {
            nd.add_input(x);
            nd.add_input(y);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'LogicalOr' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        y: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<LogicalOrInst> {
        let op = scope.new_operation("LogicalOr", |builder| {
            builder.add_input(x);
            builder.add_input(y);
            ::std::result::Result::Ok(())
        })?;
        Ok(LogicalOrInst { op })
    }
}
impl LogicalOrInst {
    /// Returns the 'z' Output of this 'LogicalOr' operation.
    pub fn z(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'LogicalOr' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'y' Input of this 'LogicalOr' operation.
    pub fn y(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<LogicalOrInst> for crate::Operation {
    fn from(inst: LogicalOrInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `LogicalOr::new().build(x, y, scope)`.
pub fn logical_or<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    x: O0,
    y: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    LogicalOr::new().build(x, y, scope)
}

/// Builder for the `LookupTableExport` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct LookupTableExport {
    Tkeys: ::std::option::Option<crate::DataType>,
    Tvalues: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'LookupTableExport' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct LookupTableExportInst {
    /// An instance of a fully built LookupTableExport Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl LookupTableExport {
    /// Creates a new `LookupTableExport`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `Tkeys` attribute.
    pub fn Tkeys<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Tkeys = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tvalues` attribute.
    pub fn Tvalues<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tvalues = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `LookupTableExport` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        table_handle: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(table_handle.into(), scope)
    }
    fn build_impl(
        &self,
        table_handle: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("LookupTableExport", |nd| {
            nd.add_input(table_handle);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.Tkeys {
                nd.set_attr_type("Tkeys", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tvalues {
                nd.set_attr_type("Tvalues", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'LookupTableExport' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        table_handle: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<LookupTableExportInst> {
        let op = scope.new_operation("LookupTableExport", |builder| {
            builder.add_input(table_handle);
            if let ::std::option::Option::Some(value) = &self.Tkeys {
                builder.set_attr_type("Tkeys", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tvalues {
                builder.set_attr_type("Tvalues", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(LookupTableExportInst { op })
    }
}
impl LookupTableExportInst {
    /// Returns the 'keys' Output of this 'LookupTableExport' operation.
    pub fn keys(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'values' Output of this 'LookupTableExport' operation.
    pub fn values(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'table_handle' Input of this 'LookupTableExport' operation.
    pub fn table_handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<LookupTableExportInst> for crate::Operation {
    fn from(inst: LookupTableExportInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `LookupTableExport::new().build(table_handle, scope)`.
pub fn lookup_table_export<O0: ::std::convert::Into<crate::Output>>(
    table_handle: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    LookupTableExport::new().build(table_handle, scope)
}

/// Builder for the `LookupTableExportV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct LookupTableExportV2 {
    Tkeys: ::std::option::Option<crate::DataType>,
    Tvalues: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'LookupTableExportV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct LookupTableExportV2Inst {
    /// An instance of a fully built LookupTableExportV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl LookupTableExportV2 {
    /// Creates a new `LookupTableExportV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `Tkeys` attribute.
    pub fn Tkeys<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Tkeys = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tvalues` attribute.
    pub fn Tvalues<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tvalues = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `LookupTableExportV2` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        table_handle: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(table_handle.into(), scope)
    }
    fn build_impl(
        &self,
        table_handle: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("LookupTableExportV2", |nd| {
            nd.add_input(table_handle);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.Tkeys {
                nd.set_attr_type("Tkeys", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tvalues {
                nd.set_attr_type("Tvalues", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'LookupTableExportV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        table_handle: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<LookupTableExportV2Inst> {
        let op = scope.new_operation("LookupTableExportV2", |builder| {
            builder.add_input(table_handle);
            if let ::std::option::Option::Some(value) = &self.Tkeys {
                builder.set_attr_type("Tkeys", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tvalues {
                builder.set_attr_type("Tvalues", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(LookupTableExportV2Inst { op })
    }
}
impl LookupTableExportV2Inst {
    /// Returns the 'keys' Output of this 'LookupTableExportV2' operation.
    pub fn keys(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'values' Output of this 'LookupTableExportV2' operation.
    pub fn values(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'table_handle' Input of this 'LookupTableExportV2' operation.
    pub fn table_handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<LookupTableExportV2Inst> for crate::Operation {
    fn from(inst: LookupTableExportV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `LookupTableExportV2::new().build(table_handle, scope)`.
pub fn lookup_table_export_v2<O0: ::std::convert::Into<crate::Output>>(
    table_handle: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    LookupTableExportV2::new().build(table_handle, scope)
}

/// Builder for the `LookupTableFind` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct LookupTableFind {
    Tin: ::std::option::Option<crate::DataType>,
    Tout: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'LookupTableFind' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct LookupTableFindInst {
    /// An instance of a fully built LookupTableFind Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl LookupTableFind {
    /// Creates a new `LookupTableFind`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `Tin` attribute.
    pub fn Tin<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Tin = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tout` attribute.
    pub fn Tout<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Tout = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `LookupTableFind` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        table_handle: O0,
        keys: O1,
        default_value: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            table_handle.into(),
            keys.into(),
            default_value.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        table_handle: crate::Output,
        keys: crate::Output,
        default_value: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("LookupTableFind", |nd| {
            nd.add_input(table_handle);
            nd.add_input(keys);
            nd.add_input(default_value);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.Tin {
                nd.set_attr_type("Tin", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tout {
                nd.set_attr_type("Tout", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'LookupTableFind' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        table_handle: crate::Output,
        keys: crate::Output,
        default_value: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<LookupTableFindInst> {
        let op = scope.new_operation("LookupTableFind", |builder| {
            builder.add_input(table_handle);
            builder.add_input(keys);
            builder.add_input(default_value);
            if let ::std::option::Option::Some(value) = &self.Tin {
                builder.set_attr_type("Tin", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tout {
                builder.set_attr_type("Tout", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(LookupTableFindInst { op })
    }
}
impl LookupTableFindInst {
    /// Returns the 'values' Output of this 'LookupTableFind' operation.
    pub fn values(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'table_handle' Input of this 'LookupTableFind' operation.
    pub fn table_handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'keys' Input of this 'LookupTableFind' operation.
    pub fn keys(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'default_value' Input of this 'LookupTableFind' operation.
    pub fn default_value(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<LookupTableFindInst> for crate::Operation {
    fn from(inst: LookupTableFindInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `LookupTableFind::new().build(table_handle, keys, default_value, scope)`.
pub fn lookup_table_find<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    table_handle: O0,
    keys: O1,
    default_value: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    LookupTableFind::new().build(table_handle, keys, default_value, scope)
}

/// Builder for the `LookupTableFindV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct LookupTableFindV2 {
    Tin: ::std::option::Option<crate::DataType>,
    Tout: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'LookupTableFindV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct LookupTableFindV2Inst {
    /// An instance of a fully built LookupTableFindV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl LookupTableFindV2 {
    /// Creates a new `LookupTableFindV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `Tin` attribute.
    pub fn Tin<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Tin = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tout` attribute.
    pub fn Tout<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Tout = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `LookupTableFindV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        table_handle: O0,
        keys: O1,
        default_value: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            table_handle.into(),
            keys.into(),
            default_value.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        table_handle: crate::Output,
        keys: crate::Output,
        default_value: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("LookupTableFindV2", |nd| {
            nd.add_input(table_handle);
            nd.add_input(keys);
            nd.add_input(default_value);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.Tin {
                nd.set_attr_type("Tin", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tout {
                nd.set_attr_type("Tout", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'LookupTableFindV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        table_handle: crate::Output,
        keys: crate::Output,
        default_value: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<LookupTableFindV2Inst> {
        let op = scope.new_operation("LookupTableFindV2", |builder| {
            builder.add_input(table_handle);
            builder.add_input(keys);
            builder.add_input(default_value);
            if let ::std::option::Option::Some(value) = &self.Tin {
                builder.set_attr_type("Tin", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tout {
                builder.set_attr_type("Tout", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(LookupTableFindV2Inst { op })
    }
}
impl LookupTableFindV2Inst {
    /// Returns the 'values' Output of this 'LookupTableFindV2' operation.
    pub fn values(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'table_handle' Input of this 'LookupTableFindV2' operation.
    pub fn table_handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'keys' Input of this 'LookupTableFindV2' operation.
    pub fn keys(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'default_value' Input of this 'LookupTableFindV2' operation.
    pub fn default_value(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<LookupTableFindV2Inst> for crate::Operation {
    fn from(inst: LookupTableFindV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `LookupTableFindV2::new().build(table_handle, keys, default_value, scope)`.
pub fn lookup_table_find_v2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    table_handle: O0,
    keys: O1,
    default_value: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    LookupTableFindV2::new().build(table_handle, keys, default_value, scope)
}

/// Builder for the `LookupTableImport` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct LookupTableImport {
    Tin: ::std::option::Option<crate::DataType>,
    Tout: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'LookupTableImport' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct LookupTableImportInst {
    /// An instance of a fully built LookupTableImport Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl LookupTableImport {
    /// Creates a new `LookupTableImport`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `Tin` attribute.
    pub fn Tin<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Tin = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tout` attribute.
    pub fn Tout<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Tout = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `LookupTableImport` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        table_handle: O0,
        keys: O1,
        values: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(table_handle.into(), keys.into(), values.into(), scope)
    }
    fn build_impl(
        &self,
        table_handle: crate::Output,
        keys: crate::Output,
        values: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("LookupTableImport", |nd| {
            nd.add_input(table_handle);
            nd.add_input(keys);
            nd.add_input(values);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.Tin {
                nd.set_attr_type("Tin", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tout {
                nd.set_attr_type("Tout", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'LookupTableImport' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        table_handle: crate::Output,
        keys: crate::Output,
        values: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<LookupTableImportInst> {
        let op = scope.new_operation("LookupTableImport", |builder| {
            builder.add_input(table_handle);
            builder.add_input(keys);
            builder.add_input(values);
            if let ::std::option::Option::Some(value) = &self.Tin {
                builder.set_attr_type("Tin", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tout {
                builder.set_attr_type("Tout", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(LookupTableImportInst { op })
    }
}
impl LookupTableImportInst {
    /// Returns the 'table_handle' Input of this 'LookupTableImport' operation.
    pub fn table_handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'keys' Input of this 'LookupTableImport' operation.
    pub fn keys(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'values' Input of this 'LookupTableImport' operation.
    pub fn values(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<LookupTableImportInst> for crate::Operation {
    fn from(inst: LookupTableImportInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `LookupTableImport::new().build(table_handle, keys, values, scope)`.
pub fn lookup_table_import<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    table_handle: O0,
    keys: O1,
    values: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    LookupTableImport::new().build(table_handle, keys, values, scope)
}

/// Builder for the `LookupTableImportV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct LookupTableImportV2 {
    Tin: ::std::option::Option<crate::DataType>,
    Tout: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'LookupTableImportV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct LookupTableImportV2Inst {
    /// An instance of a fully built LookupTableImportV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl LookupTableImportV2 {
    /// Creates a new `LookupTableImportV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `Tin` attribute.
    pub fn Tin<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Tin = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tout` attribute.
    pub fn Tout<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Tout = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `LookupTableImportV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        table_handle: O0,
        keys: O1,
        values: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(table_handle.into(), keys.into(), values.into(), scope)
    }
    fn build_impl(
        &self,
        table_handle: crate::Output,
        keys: crate::Output,
        values: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("LookupTableImportV2", |nd| {
            nd.add_input(table_handle);
            nd.add_input(keys);
            nd.add_input(values);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.Tin {
                nd.set_attr_type("Tin", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tout {
                nd.set_attr_type("Tout", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'LookupTableImportV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        table_handle: crate::Output,
        keys: crate::Output,
        values: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<LookupTableImportV2Inst> {
        let op = scope.new_operation("LookupTableImportV2", |builder| {
            builder.add_input(table_handle);
            builder.add_input(keys);
            builder.add_input(values);
            if let ::std::option::Option::Some(value) = &self.Tin {
                builder.set_attr_type("Tin", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tout {
                builder.set_attr_type("Tout", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(LookupTableImportV2Inst { op })
    }
}
impl LookupTableImportV2Inst {
    /// Returns the 'table_handle' Input of this 'LookupTableImportV2' operation.
    pub fn table_handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'keys' Input of this 'LookupTableImportV2' operation.
    pub fn keys(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'values' Input of this 'LookupTableImportV2' operation.
    pub fn values(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<LookupTableImportV2Inst> for crate::Operation {
    fn from(inst: LookupTableImportV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `LookupTableImportV2::new().build(table_handle, keys, values, scope)`.
pub fn lookup_table_import_v2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    table_handle: O0,
    keys: O1,
    values: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    LookupTableImportV2::new().build(table_handle, keys, values, scope)
}

/// Builder for the `LookupTableInsert` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct LookupTableInsert {
    Tin: ::std::option::Option<crate::DataType>,
    Tout: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'LookupTableInsert' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct LookupTableInsertInst {
    /// An instance of a fully built LookupTableInsert Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl LookupTableInsert {
    /// Creates a new `LookupTableInsert`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `Tin` attribute.
    pub fn Tin<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Tin = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tout` attribute.
    pub fn Tout<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Tout = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `LookupTableInsert` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        table_handle: O0,
        keys: O1,
        values: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(table_handle.into(), keys.into(), values.into(), scope)
    }
    fn build_impl(
        &self,
        table_handle: crate::Output,
        keys: crate::Output,
        values: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("LookupTableInsert", |nd| {
            nd.add_input(table_handle);
            nd.add_input(keys);
            nd.add_input(values);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.Tin {
                nd.set_attr_type("Tin", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tout {
                nd.set_attr_type("Tout", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'LookupTableInsert' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        table_handle: crate::Output,
        keys: crate::Output,
        values: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<LookupTableInsertInst> {
        let op = scope.new_operation("LookupTableInsert", |builder| {
            builder.add_input(table_handle);
            builder.add_input(keys);
            builder.add_input(values);
            if let ::std::option::Option::Some(value) = &self.Tin {
                builder.set_attr_type("Tin", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tout {
                builder.set_attr_type("Tout", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(LookupTableInsertInst { op })
    }
}
impl LookupTableInsertInst {
    /// Returns the 'table_handle' Input of this 'LookupTableInsert' operation.
    pub fn table_handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'keys' Input of this 'LookupTableInsert' operation.
    pub fn keys(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'values' Input of this 'LookupTableInsert' operation.
    pub fn values(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<LookupTableInsertInst> for crate::Operation {
    fn from(inst: LookupTableInsertInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `LookupTableInsert::new().build(table_handle, keys, values, scope)`.
pub fn lookup_table_insert<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    table_handle: O0,
    keys: O1,
    values: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    LookupTableInsert::new().build(table_handle, keys, values, scope)
}

/// Builder for the `LookupTableInsertV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct LookupTableInsertV2 {
    Tin: ::std::option::Option<crate::DataType>,
    Tout: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'LookupTableInsertV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct LookupTableInsertV2Inst {
    /// An instance of a fully built LookupTableInsertV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl LookupTableInsertV2 {
    /// Creates a new `LookupTableInsertV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `Tin` attribute.
    pub fn Tin<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Tin = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tout` attribute.
    pub fn Tout<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Tout = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `LookupTableInsertV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        table_handle: O0,
        keys: O1,
        values: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(table_handle.into(), keys.into(), values.into(), scope)
    }
    fn build_impl(
        &self,
        table_handle: crate::Output,
        keys: crate::Output,
        values: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("LookupTableInsertV2", |nd| {
            nd.add_input(table_handle);
            nd.add_input(keys);
            nd.add_input(values);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.Tin {
                nd.set_attr_type("Tin", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tout {
                nd.set_attr_type("Tout", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'LookupTableInsertV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        table_handle: crate::Output,
        keys: crate::Output,
        values: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<LookupTableInsertV2Inst> {
        let op = scope.new_operation("LookupTableInsertV2", |builder| {
            builder.add_input(table_handle);
            builder.add_input(keys);
            builder.add_input(values);
            if let ::std::option::Option::Some(value) = &self.Tin {
                builder.set_attr_type("Tin", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tout {
                builder.set_attr_type("Tout", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(LookupTableInsertV2Inst { op })
    }
}
impl LookupTableInsertV2Inst {
    /// Returns the 'table_handle' Input of this 'LookupTableInsertV2' operation.
    pub fn table_handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'keys' Input of this 'LookupTableInsertV2' operation.
    pub fn keys(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'values' Input of this 'LookupTableInsertV2' operation.
    pub fn values(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<LookupTableInsertV2Inst> for crate::Operation {
    fn from(inst: LookupTableInsertV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `LookupTableInsertV2::new().build(table_handle, keys, values, scope)`.
pub fn lookup_table_insert_v2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    table_handle: O0,
    keys: O1,
    values: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    LookupTableInsertV2::new().build(table_handle, keys, values, scope)
}

/// Builder for the `LookupTableRemoveV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct LookupTableRemoveV2 {
    Tin: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'LookupTableRemoveV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct LookupTableRemoveV2Inst {
    /// An instance of a fully built LookupTableRemoveV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl LookupTableRemoveV2 {
    /// Creates a new `LookupTableRemoveV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `Tin` attribute.
    pub fn Tin<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Tin = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `LookupTableRemoveV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        table_handle: O0,
        keys: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(table_handle.into(), keys.into(), scope)
    }
    fn build_impl(
        &self,
        table_handle: crate::Output,
        keys: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("LookupTableRemoveV2", |nd| {
            nd.add_input(table_handle);
            nd.add_input(keys);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.Tin {
                nd.set_attr_type("Tin", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'LookupTableRemoveV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        table_handle: crate::Output,
        keys: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<LookupTableRemoveV2Inst> {
        let op = scope.new_operation("LookupTableRemoveV2", |builder| {
            builder.add_input(table_handle);
            builder.add_input(keys);
            if let ::std::option::Option::Some(value) = &self.Tin {
                builder.set_attr_type("Tin", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(LookupTableRemoveV2Inst { op })
    }
}
impl LookupTableRemoveV2Inst {
    /// Returns the 'table_handle' Input of this 'LookupTableRemoveV2' operation.
    pub fn table_handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'keys' Input of this 'LookupTableRemoveV2' operation.
    pub fn keys(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<LookupTableRemoveV2Inst> for crate::Operation {
    fn from(inst: LookupTableRemoveV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `LookupTableRemoveV2::new().build(table_handle, keys, scope)`.
pub fn lookup_table_remove_v2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    table_handle: O0,
    keys: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    LookupTableRemoveV2::new().build(table_handle, keys, scope)
}

/// Builder for the `LookupTableSize` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct LookupTableSize {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'LookupTableSize' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct LookupTableSizeInst {
    /// An instance of a fully built LookupTableSize Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl LookupTableSize {
    /// Creates a new `LookupTableSize`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `LookupTableSize` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        table_handle: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(table_handle.into(), scope)
    }
    fn build_impl(
        &self,
        table_handle: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("LookupTableSize", |nd| {
            nd.add_input(table_handle);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'LookupTableSize' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        table_handle: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<LookupTableSizeInst> {
        let op = scope.new_operation("LookupTableSize", |builder| {
            builder.add_input(table_handle);
            ::std::result::Result::Ok(())
        })?;
        Ok(LookupTableSizeInst { op })
    }
}
impl LookupTableSizeInst {
    /// Returns the 'size' Output of this 'LookupTableSize' operation.
    pub fn size(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'table_handle' Input of this 'LookupTableSize' operation.
    pub fn table_handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<LookupTableSizeInst> for crate::Operation {
    fn from(inst: LookupTableSizeInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `LookupTableSize::new().build(table_handle, scope)`.
pub fn lookup_table_size<O0: ::std::convert::Into<crate::Output>>(
    table_handle: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    LookupTableSize::new().build(table_handle, scope)
}

/// Builder for the `LookupTableSizeV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct LookupTableSizeV2 {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'LookupTableSizeV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct LookupTableSizeV2Inst {
    /// An instance of a fully built LookupTableSizeV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl LookupTableSizeV2 {
    /// Creates a new `LookupTableSizeV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `LookupTableSizeV2` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        table_handle: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(table_handle.into(), scope)
    }
    fn build_impl(
        &self,
        table_handle: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("LookupTableSizeV2", |nd| {
            nd.add_input(table_handle);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'LookupTableSizeV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        table_handle: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<LookupTableSizeV2Inst> {
        let op = scope.new_operation("LookupTableSizeV2", |builder| {
            builder.add_input(table_handle);
            ::std::result::Result::Ok(())
        })?;
        Ok(LookupTableSizeV2Inst { op })
    }
}
impl LookupTableSizeV2Inst {
    /// Returns the 'size' Output of this 'LookupTableSizeV2' operation.
    pub fn size(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'table_handle' Input of this 'LookupTableSizeV2' operation.
    pub fn table_handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<LookupTableSizeV2Inst> for crate::Operation {
    fn from(inst: LookupTableSizeV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `LookupTableSizeV2::new().build(table_handle, scope)`.
pub fn lookup_table_size_v2<O0: ::std::convert::Into<crate::Output>>(
    table_handle: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    LookupTableSizeV2::new().build(table_handle, scope)
}

/// Builder for the `LoopCond` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct LoopCond {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'LoopCond' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct LoopCondInst {
    /// An instance of a fully built LoopCond Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl LoopCond {
    /// Creates a new `LoopCond`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `LoopCond` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("LoopCond", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'LoopCond' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<LoopCondInst> {
        let op = scope.new_operation("LoopCond", |builder| {
            builder.add_input(input);
            ::std::result::Result::Ok(())
        })?;
        Ok(LoopCondInst { op })
    }
}
impl LoopCondInst {
    /// Returns the 'output' Output of this 'LoopCond' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'LoopCond' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<LoopCondInst> for crate::Operation {
    fn from(inst: LoopCondInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `LoopCond::new().build(input, scope)`.
pub fn loop_cond<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    LoopCond::new().build(input, scope)
}

/// Builder for the `LowerBound` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct LowerBound {
    T: ::std::option::Option<crate::DataType>,
    out_type: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'LowerBound' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct LowerBoundInst {
    /// An instance of a fully built LowerBound Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl LowerBound {
    /// Creates a new `LowerBound`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `out_type` attribute.
    pub fn out_type<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.out_type = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `LowerBound` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        sorted_inputs: O0,
        values: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(sorted_inputs.into(), values.into(), scope)
    }
    fn build_impl(
        &self,
        sorted_inputs: crate::Output,
        values: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("LowerBound", |nd| {
            nd.add_input(sorted_inputs);
            nd.add_input(values);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.out_type {
                nd.set_attr_type("out_type", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'LowerBound' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        sorted_inputs: crate::Output,
        values: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<LowerBoundInst> {
        let op = scope.new_operation("LowerBound", |builder| {
            builder.add_input(sorted_inputs);
            builder.add_input(values);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.out_type {
                builder.set_attr_type("out_type", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(LowerBoundInst { op })
    }
}
impl LowerBoundInst {
    /// Returns the 'output' Output of this 'LowerBound' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'sorted_inputs' Input of this 'LowerBound' operation.
    pub fn sorted_inputs(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'values' Input of this 'LowerBound' operation.
    pub fn values(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<LowerBoundInst> for crate::Operation {
    fn from(inst: LowerBoundInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `LowerBound::new().build(sorted_inputs, values, scope)`.
pub fn lower_bound<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    sorted_inputs: O0,
    values: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    LowerBound::new().build(sorted_inputs, values, scope)
}

/// Builder for the `Lu` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Lu {
    T: ::std::option::Option<crate::DataType>,
    output_idx_type: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Lu' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct LuInst {
    /// An instance of a fully built Lu Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Lu {
    /// Creates a new `Lu`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_idx_type` attribute.
    pub fn output_idx_type<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_idx_type = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Lu` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Lu", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_idx_type {
                nd.set_attr_type("output_idx_type", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Lu' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<LuInst> {
        let op = scope.new_operation("Lu", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_idx_type {
                builder.set_attr_type("output_idx_type", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(LuInst { op })
    }
}
impl LuInst {
    /// Returns the 'lu' Output of this 'Lu' operation.
    pub fn lu(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'p' Output of this 'Lu' operation.
    pub fn p(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'input' Input of this 'Lu' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<LuInst> for crate::Operation {
    fn from(inst: LuInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Lu::new().build(input, scope)`.
pub fn lu<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Lu::new().build(input, scope)
}

/// Builder for the `MakeIterator` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct MakeIterator {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'MakeIterator' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct MakeIteratorInst {
    /// An instance of a fully built MakeIterator Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl MakeIterator {
    /// Creates a new `MakeIterator`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `MakeIterator` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        dataset: O0,
        iterator: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(dataset.into(), iterator.into(), scope)
    }
    fn build_impl(
        &self,
        dataset: crate::Output,
        iterator: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("MakeIterator", |nd| {
            nd.add_input(dataset);
            nd.add_input(iterator);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'MakeIterator' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        dataset: crate::Output,
        iterator: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<MakeIteratorInst> {
        let op = scope.new_operation("MakeIterator", |builder| {
            builder.add_input(dataset);
            builder.add_input(iterator);
            ::std::result::Result::Ok(())
        })?;
        Ok(MakeIteratorInst { op })
    }
}
impl MakeIteratorInst {
    /// Returns the 'dataset' Input of this 'MakeIterator' operation.
    pub fn dataset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'iterator' Input of this 'MakeIterator' operation.
    pub fn iterator(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<MakeIteratorInst> for crate::Operation {
    fn from(inst: MakeIteratorInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `MakeIterator::new().build(dataset, iterator, scope)`.
pub fn make_iterator<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    dataset: O0,
    iterator: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    MakeIterator::new().build(dataset, iterator, scope)
}

/// Builder for the `MakeUnique` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct MakeUnique {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'MakeUnique' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct MakeUniqueInst {
    /// An instance of a fully built MakeUnique Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl MakeUnique {
    /// Creates a new `MakeUnique`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `MakeUnique` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("MakeUnique", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'MakeUnique' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<MakeUniqueInst> {
        let op = scope.new_operation("MakeUnique", |builder| {
            builder.add_input(input);
            ::std::result::Result::Ok(())
        })?;
        Ok(MakeUniqueInst { op })
    }
}
impl MakeUniqueInst {
    /// Returns the 'output' Output of this 'MakeUnique' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'MakeUnique' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<MakeUniqueInst> for crate::Operation {
    fn from(inst: MakeUniqueInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `MakeUnique::new().build(input, scope)`.
pub fn make_unique<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    MakeUnique::new().build(input, scope)
}

/// Builder for the `MapAndBatchDataset` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct MapAndBatchDataset {
    f: ::std::option::Option<::std::string::String>,
    Targuments: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    preserve_cardinality: ::std::option::Option<bool>,
    metadata: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'MapAndBatchDataset' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct MapAndBatchDatasetInst {
    /// An instance of a fully built MapAndBatchDataset Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl MapAndBatchDataset {
    /// Creates a new `MapAndBatchDataset`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `f` attribute.
    pub fn f<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.f = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Targuments` attribute.
    pub fn Targuments<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Targuments = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `preserve_cardinality` attribute.
    pub fn preserve_cardinality<ArgType: ::std::convert::Into<bool>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.preserve_cardinality = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `metadata` attribute.
    pub fn metadata<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.metadata = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `MapAndBatchDataset` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input_dataset: O0,
        other_arguments: O1,
        batch_size: O2,
        num_parallel_calls: O3,
        drop_remainder: O4,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            input_dataset.into(),
            other_arguments.into(),
            batch_size.into(),
            num_parallel_calls.into(),
            drop_remainder.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        input_dataset: crate::Output,
        other_arguments: crate::Output,
        batch_size: crate::Output,
        num_parallel_calls: crate::Output,
        drop_remainder: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("MapAndBatchDataset", |nd| {
            nd.add_input(input_dataset);
            nd.add_input(other_arguments);
            nd.add_input(batch_size);
            nd.add_input(num_parallel_calls);
            nd.add_input(drop_remainder);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.f {
                nd.set_attr_string("f", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Targuments {
                nd.set_attr_type_list("Targuments", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.preserve_cardinality {
                nd.set_attr_bool("preserve_cardinality", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.metadata {
                nd.set_attr_string("metadata", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'MapAndBatchDataset' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_dataset: crate::Output,
        other_arguments: crate::Output,
        batch_size: crate::Output,
        num_parallel_calls: crate::Output,
        drop_remainder: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<MapAndBatchDatasetInst> {
        let op = scope.new_operation("MapAndBatchDataset", |builder| {
            builder.add_input(input_dataset);
            builder.add_input(other_arguments);
            builder.add_input(batch_size);
            builder.add_input(num_parallel_calls);
            builder.add_input(drop_remainder);
            if let ::std::option::Option::Some(value) = &self.f {
                builder.set_attr_string("f", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Targuments {
                builder.set_attr_type_list("Targuments", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.preserve_cardinality {
                builder.set_attr_bool("preserve_cardinality", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.metadata {
                builder.set_attr_string("metadata", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(MapAndBatchDatasetInst { op })
    }
}
impl MapAndBatchDatasetInst {
    /// Returns the 'handle' Output of this 'MapAndBatchDataset' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_dataset' Input of this 'MapAndBatchDataset' operation.
    pub fn input_dataset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'other_arguments' Input of this 'MapAndBatchDataset' operation.
    pub fn other_arguments(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'batch_size' Input of this 'MapAndBatchDataset' operation.
    pub fn batch_size(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'num_parallel_calls' Input of this 'MapAndBatchDataset' operation.
    pub fn num_parallel_calls(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'drop_remainder' Input of this 'MapAndBatchDataset' operation.
    pub fn drop_remainder(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
}
impl From<MapAndBatchDatasetInst> for crate::Operation {
    fn from(inst: MapAndBatchDatasetInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `MapAndBatchDataset::new().build(input_dataset, other_arguments, batch_size, num_parallel_calls, drop_remainder, scope)`.
pub fn map_and_batch_dataset<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
>(
    input_dataset: O0,
    other_arguments: O1,
    batch_size: O2,
    num_parallel_calls: O3,
    drop_remainder: O4,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    MapAndBatchDataset::new().build(
        input_dataset,
        other_arguments,
        batch_size,
        num_parallel_calls,
        drop_remainder,
        scope,
    )
}

/// Builder for the `MapClear` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct MapClear {
    capacity: ::std::option::Option<i64>,
    memory_limit: ::std::option::Option<i64>,
    dtypes: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    container: ::std::option::Option<::std::string::String>,
    shared_name: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'MapClear' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct MapClearInst {
    /// An instance of a fully built MapClear Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl MapClear {
    /// Creates a new `MapClear`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `capacity` attribute.
    pub fn capacity<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.capacity = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `memory_limit` attribute.
    pub fn memory_limit<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.memory_limit = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `dtypes` attribute.
    pub fn dtypes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.dtypes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `container` attribute.
    pub fn container<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.container = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shared_name` attribute.
    pub fn shared_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.shared_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `MapClear` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("MapClear", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.capacity {
                nd.set_attr_int("capacity", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.memory_limit {
                nd.set_attr_int("memory_limit", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dtypes {
                nd.set_attr_type_list("dtypes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.container {
                nd.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                nd.set_attr_string("shared_name", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'MapClear' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(&self, scope: &mut crate::Scope) -> crate::Result<MapClearInst> {
        let op = scope.new_operation("MapClear", |builder| {
            if let ::std::option::Option::Some(value) = &self.capacity {
                builder.set_attr_int("capacity", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.memory_limit {
                builder.set_attr_int("memory_limit", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dtypes {
                builder.set_attr_type_list("dtypes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.container {
                builder.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                builder.set_attr_string("shared_name", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(MapClearInst { op })
    }
}
impl MapClearInst {}
impl From<MapClearInst> for crate::Operation {
    fn from(inst: MapClearInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `MapClear::new().build(scope)`.
pub fn map_clear(scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
    MapClear::new().build(scope)
}

/// Builder for the `MapDataset` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct MapDataset {
    f: ::std::option::Option<::std::string::String>,
    Targuments: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    use_inter_op_parallelism: ::std::option::Option<bool>,
    preserve_cardinality: ::std::option::Option<bool>,
    metadata: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'MapDataset' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct MapDatasetInst {
    /// An instance of a fully built MapDataset Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl MapDataset {
    /// Creates a new `MapDataset`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `f` attribute.
    pub fn f<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.f = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Targuments` attribute.
    pub fn Targuments<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Targuments = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_inter_op_parallelism` attribute.
    pub fn use_inter_op_parallelism<ArgType: ::std::convert::Into<bool>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.use_inter_op_parallelism = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `preserve_cardinality` attribute.
    pub fn preserve_cardinality<ArgType: ::std::convert::Into<bool>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.preserve_cardinality = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `metadata` attribute.
    pub fn metadata<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.metadata = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `MapDataset` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input_dataset: O0,
        other_arguments: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input_dataset.into(), other_arguments.into(), scope)
    }
    fn build_impl(
        &self,
        input_dataset: crate::Output,
        other_arguments: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("MapDataset", |nd| {
            nd.add_input(input_dataset);
            nd.add_input(other_arguments);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.f {
                nd.set_attr_string("f", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Targuments {
                nd.set_attr_type_list("Targuments", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_inter_op_parallelism {
                nd.set_attr_bool("use_inter_op_parallelism", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.preserve_cardinality {
                nd.set_attr_bool("preserve_cardinality", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.metadata {
                nd.set_attr_string("metadata", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'MapDataset' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_dataset: crate::Output,
        other_arguments: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<MapDatasetInst> {
        let op = scope.new_operation("MapDataset", |builder| {
            builder.add_input(input_dataset);
            builder.add_input(other_arguments);
            if let ::std::option::Option::Some(value) = &self.f {
                builder.set_attr_string("f", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Targuments {
                builder.set_attr_type_list("Targuments", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_inter_op_parallelism {
                builder.set_attr_bool("use_inter_op_parallelism", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.preserve_cardinality {
                builder.set_attr_bool("preserve_cardinality", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.metadata {
                builder.set_attr_string("metadata", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(MapDatasetInst { op })
    }
}
impl MapDatasetInst {
    /// Returns the 'handle' Output of this 'MapDataset' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_dataset' Input of this 'MapDataset' operation.
    pub fn input_dataset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'other_arguments' Input of this 'MapDataset' operation.
    pub fn other_arguments(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<MapDatasetInst> for crate::Operation {
    fn from(inst: MapDatasetInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `MapDataset::new().build(input_dataset, other_arguments, scope)`.
pub fn map_dataset<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    input_dataset: O0,
    other_arguments: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    MapDataset::new().build(input_dataset, other_arguments, scope)
}

/// Builder for the `MapDefun` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct MapDefun {
    Targuments: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    Tcaptured: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    f: ::std::option::Option<::std::string::String>,
    max_intra_op_parallelism: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'MapDefun' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct MapDefunInst {
    /// An instance of a fully built MapDefun Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl MapDefun {
    /// Creates a new `MapDefun`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `Targuments` attribute.
    pub fn Targuments<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Targuments = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tcaptured` attribute.
    pub fn Tcaptured<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tcaptured = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `f` attribute.
    pub fn f<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.f = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `max_intra_op_parallelism` attribute.
    pub fn max_intra_op_parallelism<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.max_intra_op_parallelism = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `MapDefun` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        arguments: O0,
        captured_inputs: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(arguments.into(), captured_inputs.into(), scope)
    }
    fn build_impl(
        &self,
        arguments: crate::Output,
        captured_inputs: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("MapDefun", |nd| {
            nd.add_input(arguments);
            nd.add_input(captured_inputs);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.Targuments {
                nd.set_attr_type_list("Targuments", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tcaptured {
                nd.set_attr_type_list("Tcaptured", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.f {
                nd.set_attr_string("f", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.max_intra_op_parallelism {
                nd.set_attr_int("max_intra_op_parallelism", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'MapDefun' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        arguments: crate::Output,
        captured_inputs: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<MapDefunInst> {
        let op = scope.new_operation("MapDefun", |builder| {
            builder.add_input(arguments);
            builder.add_input(captured_inputs);
            if let ::std::option::Option::Some(value) = &self.Targuments {
                builder.set_attr_type_list("Targuments", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tcaptured {
                builder.set_attr_type_list("Tcaptured", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.f {
                builder.set_attr_string("f", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.max_intra_op_parallelism {
                builder.set_attr_int("max_intra_op_parallelism", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(MapDefunInst { op })
    }
}
impl MapDefunInst {
    /// Returns the 'output' Output of this 'MapDefun' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'arguments' Input of this 'MapDefun' operation.
    pub fn arguments(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'captured_inputs' Input of this 'MapDefun' operation.
    pub fn captured_inputs(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<MapDefunInst> for crate::Operation {
    fn from(inst: MapDefunInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `MapDefun::new().build(arguments, captured_inputs, scope)`.
pub fn map_defun<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    arguments: O0,
    captured_inputs: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    MapDefun::new().build(arguments, captured_inputs, scope)
}

/// Builder for the `MapIncompleteSize` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct MapIncompleteSize {
    capacity: ::std::option::Option<i64>,
    memory_limit: ::std::option::Option<i64>,
    dtypes: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    container: ::std::option::Option<::std::string::String>,
    shared_name: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'MapIncompleteSize' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct MapIncompleteSizeInst {
    /// An instance of a fully built MapIncompleteSize Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl MapIncompleteSize {
    /// Creates a new `MapIncompleteSize`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `capacity` attribute.
    pub fn capacity<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.capacity = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `memory_limit` attribute.
    pub fn memory_limit<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.memory_limit = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `dtypes` attribute.
    pub fn dtypes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.dtypes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `container` attribute.
    pub fn container<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.container = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shared_name` attribute.
    pub fn shared_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.shared_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `MapIncompleteSize` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("MapIncompleteSize", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.capacity {
                nd.set_attr_int("capacity", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.memory_limit {
                nd.set_attr_int("memory_limit", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dtypes {
                nd.set_attr_type_list("dtypes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.container {
                nd.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                nd.set_attr_string("shared_name", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'MapIncompleteSize' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(&self, scope: &mut crate::Scope) -> crate::Result<MapIncompleteSizeInst> {
        let op = scope.new_operation("MapIncompleteSize", |builder| {
            if let ::std::option::Option::Some(value) = &self.capacity {
                builder.set_attr_int("capacity", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.memory_limit {
                builder.set_attr_int("memory_limit", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dtypes {
                builder.set_attr_type_list("dtypes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.container {
                builder.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                builder.set_attr_string("shared_name", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(MapIncompleteSizeInst { op })
    }
}
impl MapIncompleteSizeInst {
    /// Returns the 'size' Output of this 'MapIncompleteSize' operation.
    pub fn size(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
}
impl From<MapIncompleteSizeInst> for crate::Operation {
    fn from(inst: MapIncompleteSizeInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `MapIncompleteSize::new().build(scope)`.
pub fn map_incomplete_size(scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
    MapIncompleteSize::new().build(scope)
}

/// Builder for the `MapPeek` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct MapPeek {
    capacity: ::std::option::Option<i64>,
    memory_limit: ::std::option::Option<i64>,
    dtypes: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    container: ::std::option::Option<::std::string::String>,
    shared_name: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'MapPeek' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct MapPeekInst {
    /// An instance of a fully built MapPeek Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl MapPeek {
    /// Creates a new `MapPeek`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `capacity` attribute.
    pub fn capacity<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.capacity = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `memory_limit` attribute.
    pub fn memory_limit<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.memory_limit = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `dtypes` attribute.
    pub fn dtypes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.dtypes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `container` attribute.
    pub fn container<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.container = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shared_name` attribute.
    pub fn shared_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.shared_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `MapPeek` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        key: O0,
        indices: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(key.into(), indices.into(), scope)
    }
    fn build_impl(
        &self,
        key: crate::Output,
        indices: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("MapPeek", |nd| {
            nd.add_input(key);
            nd.add_input(indices);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.capacity {
                nd.set_attr_int("capacity", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.memory_limit {
                nd.set_attr_int("memory_limit", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dtypes {
                nd.set_attr_type_list("dtypes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.container {
                nd.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                nd.set_attr_string("shared_name", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'MapPeek' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        key: crate::Output,
        indices: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<MapPeekInst> {
        let op = scope.new_operation("MapPeek", |builder| {
            builder.add_input(key);
            builder.add_input(indices);
            if let ::std::option::Option::Some(value) = &self.capacity {
                builder.set_attr_int("capacity", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.memory_limit {
                builder.set_attr_int("memory_limit", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dtypes {
                builder.set_attr_type_list("dtypes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.container {
                builder.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                builder.set_attr_string("shared_name", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(MapPeekInst { op })
    }
}
impl MapPeekInst {
    /// Returns the 'values' Output of this 'MapPeek' operation.
    pub fn values(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'key' Input of this 'MapPeek' operation.
    pub fn key(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'indices' Input of this 'MapPeek' operation.
    pub fn indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<MapPeekInst> for crate::Operation {
    fn from(inst: MapPeekInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `MapPeek::new().build(key, indices, scope)`.
pub fn map_peek<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    key: O0,
    indices: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    MapPeek::new().build(key, indices, scope)
}

/// Builder for the `MapSize` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct MapSize {
    capacity: ::std::option::Option<i64>,
    memory_limit: ::std::option::Option<i64>,
    dtypes: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    container: ::std::option::Option<::std::string::String>,
    shared_name: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'MapSize' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct MapSizeInst {
    /// An instance of a fully built MapSize Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl MapSize {
    /// Creates a new `MapSize`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `capacity` attribute.
    pub fn capacity<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.capacity = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `memory_limit` attribute.
    pub fn memory_limit<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.memory_limit = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `dtypes` attribute.
    pub fn dtypes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.dtypes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `container` attribute.
    pub fn container<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.container = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shared_name` attribute.
    pub fn shared_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.shared_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `MapSize` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("MapSize", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.capacity {
                nd.set_attr_int("capacity", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.memory_limit {
                nd.set_attr_int("memory_limit", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dtypes {
                nd.set_attr_type_list("dtypes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.container {
                nd.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                nd.set_attr_string("shared_name", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'MapSize' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(&self, scope: &mut crate::Scope) -> crate::Result<MapSizeInst> {
        let op = scope.new_operation("MapSize", |builder| {
            if let ::std::option::Option::Some(value) = &self.capacity {
                builder.set_attr_int("capacity", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.memory_limit {
                builder.set_attr_int("memory_limit", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dtypes {
                builder.set_attr_type_list("dtypes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.container {
                builder.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                builder.set_attr_string("shared_name", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(MapSizeInst { op })
    }
}
impl MapSizeInst {
    /// Returns the 'size' Output of this 'MapSize' operation.
    pub fn size(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
}
impl From<MapSizeInst> for crate::Operation {
    fn from(inst: MapSizeInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `MapSize::new().build(scope)`.
pub fn map_size(scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
    MapSize::new().build(scope)
}

/// Builder for the `MapStage` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct MapStage {
    capacity: ::std::option::Option<i64>,
    memory_limit: ::std::option::Option<i64>,
    dtypes: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    fake_dtypes: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    container: ::std::option::Option<::std::string::String>,
    shared_name: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'MapStage' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct MapStageInst {
    /// An instance of a fully built MapStage Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl MapStage {
    /// Creates a new `MapStage`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `capacity` attribute.
    pub fn capacity<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.capacity = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `memory_limit` attribute.
    pub fn memory_limit<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.memory_limit = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `dtypes` attribute.
    pub fn dtypes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.dtypes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `fake_dtypes` attribute.
    pub fn fake_dtypes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.fake_dtypes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `container` attribute.
    pub fn container<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.container = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shared_name` attribute.
    pub fn shared_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.shared_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `MapStage` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        key: O0,
        indices: O1,
        values: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(key.into(), indices.into(), values.into(), scope)
    }
    fn build_impl(
        &self,
        key: crate::Output,
        indices: crate::Output,
        values: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("MapStage", |nd| {
            nd.add_input(key);
            nd.add_input(indices);
            nd.add_input(values);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.capacity {
                nd.set_attr_int("capacity", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.memory_limit {
                nd.set_attr_int("memory_limit", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dtypes {
                nd.set_attr_type_list("dtypes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.fake_dtypes {
                nd.set_attr_type_list("fake_dtypes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.container {
                nd.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                nd.set_attr_string("shared_name", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'MapStage' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        key: crate::Output,
        indices: crate::Output,
        values: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<MapStageInst> {
        let op = scope.new_operation("MapStage", |builder| {
            builder.add_input(key);
            builder.add_input(indices);
            builder.add_input(values);
            if let ::std::option::Option::Some(value) = &self.capacity {
                builder.set_attr_int("capacity", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.memory_limit {
                builder.set_attr_int("memory_limit", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dtypes {
                builder.set_attr_type_list("dtypes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.fake_dtypes {
                builder.set_attr_type_list("fake_dtypes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.container {
                builder.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                builder.set_attr_string("shared_name", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(MapStageInst { op })
    }
}
impl MapStageInst {
    /// Returns the 'key' Input of this 'MapStage' operation.
    pub fn key(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'indices' Input of this 'MapStage' operation.
    pub fn indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'values' Input of this 'MapStage' operation.
    pub fn values(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<MapStageInst> for crate::Operation {
    fn from(inst: MapStageInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `MapStage::new().build(key, indices, values, scope)`.
pub fn map_stage<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    key: O0,
    indices: O1,
    values: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    MapStage::new().build(key, indices, values, scope)
}

/// Builder for the `MapUnstage` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct MapUnstage {
    capacity: ::std::option::Option<i64>,
    memory_limit: ::std::option::Option<i64>,
    dtypes: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    container: ::std::option::Option<::std::string::String>,
    shared_name: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'MapUnstage' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct MapUnstageInst {
    /// An instance of a fully built MapUnstage Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl MapUnstage {
    /// Creates a new `MapUnstage`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `capacity` attribute.
    pub fn capacity<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.capacity = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `memory_limit` attribute.
    pub fn memory_limit<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.memory_limit = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `dtypes` attribute.
    pub fn dtypes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.dtypes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `container` attribute.
    pub fn container<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.container = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shared_name` attribute.
    pub fn shared_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.shared_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `MapUnstage` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        key: O0,
        indices: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(key.into(), indices.into(), scope)
    }
    fn build_impl(
        &self,
        key: crate::Output,
        indices: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("MapUnstage", |nd| {
            nd.add_input(key);
            nd.add_input(indices);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.capacity {
                nd.set_attr_int("capacity", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.memory_limit {
                nd.set_attr_int("memory_limit", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dtypes {
                nd.set_attr_type_list("dtypes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.container {
                nd.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                nd.set_attr_string("shared_name", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'MapUnstage' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        key: crate::Output,
        indices: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<MapUnstageInst> {
        let op = scope.new_operation("MapUnstage", |builder| {
            builder.add_input(key);
            builder.add_input(indices);
            if let ::std::option::Option::Some(value) = &self.capacity {
                builder.set_attr_int("capacity", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.memory_limit {
                builder.set_attr_int("memory_limit", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dtypes {
                builder.set_attr_type_list("dtypes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.container {
                builder.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                builder.set_attr_string("shared_name", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(MapUnstageInst { op })
    }
}
impl MapUnstageInst {
    /// Returns the 'values' Output of this 'MapUnstage' operation.
    pub fn values(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'key' Input of this 'MapUnstage' operation.
    pub fn key(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'indices' Input of this 'MapUnstage' operation.
    pub fn indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<MapUnstageInst> for crate::Operation {
    fn from(inst: MapUnstageInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `MapUnstage::new().build(key, indices, scope)`.
pub fn map_unstage<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    key: O0,
    indices: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    MapUnstage::new().build(key, indices, scope)
}

/// Builder for the `MapUnstageNoKey` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct MapUnstageNoKey {
    capacity: ::std::option::Option<i64>,
    memory_limit: ::std::option::Option<i64>,
    dtypes: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    container: ::std::option::Option<::std::string::String>,
    shared_name: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'MapUnstageNoKey' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct MapUnstageNoKeyInst {
    /// An instance of a fully built MapUnstageNoKey Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl MapUnstageNoKey {
    /// Creates a new `MapUnstageNoKey`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `capacity` attribute.
    pub fn capacity<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.capacity = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `memory_limit` attribute.
    pub fn memory_limit<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.memory_limit = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `dtypes` attribute.
    pub fn dtypes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.dtypes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `container` attribute.
    pub fn container<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.container = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shared_name` attribute.
    pub fn shared_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.shared_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `MapUnstageNoKey` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        indices: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(indices.into(), scope)
    }
    fn build_impl(
        &self,
        indices: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("MapUnstageNoKey", |nd| {
            nd.add_input(indices);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.capacity {
                nd.set_attr_int("capacity", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.memory_limit {
                nd.set_attr_int("memory_limit", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dtypes {
                nd.set_attr_type_list("dtypes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.container {
                nd.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                nd.set_attr_string("shared_name", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'MapUnstageNoKey' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        indices: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<MapUnstageNoKeyInst> {
        let op = scope.new_operation("MapUnstageNoKey", |builder| {
            builder.add_input(indices);
            if let ::std::option::Option::Some(value) = &self.capacity {
                builder.set_attr_int("capacity", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.memory_limit {
                builder.set_attr_int("memory_limit", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dtypes {
                builder.set_attr_type_list("dtypes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.container {
                builder.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                builder.set_attr_string("shared_name", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(MapUnstageNoKeyInst { op })
    }
}
impl MapUnstageNoKeyInst {
    /// Returns the 'key' Output of this 'MapUnstageNoKey' operation.
    pub fn key(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'values' Output of this 'MapUnstageNoKey' operation.
    pub fn values(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'indices' Input of this 'MapUnstageNoKey' operation.
    pub fn indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<MapUnstageNoKeyInst> for crate::Operation {
    fn from(inst: MapUnstageNoKeyInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `MapUnstageNoKey::new().build(indices, scope)`.
pub fn map_unstage_no_key<O0: ::std::convert::Into<crate::Output>>(
    indices: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    MapUnstageNoKey::new().build(indices, scope)
}

/// Builder for the `MatMul` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct MatMul {
    transpose_a: ::std::option::Option<bool>,
    transpose_b: ::std::option::Option<bool>,
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'MatMul' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct MatMulInst {
    /// An instance of a fully built MatMul Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl MatMul {
    /// Creates a new `MatMul`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `transpose_a` attribute.
    pub fn transpose_a<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.transpose_a = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `transpose_b` attribute.
    pub fn transpose_b<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.transpose_b = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `MatMul` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        a: O0,
        b: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(a.into(), b.into(), scope)
    }
    fn build_impl(
        &self,
        a: crate::Output,
        b: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("MatMul", |nd| {
            nd.add_input(a);
            nd.add_input(b);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.transpose_a {
                nd.set_attr_bool("transpose_a", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.transpose_b {
                nd.set_attr_bool("transpose_b", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'MatMul' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        a: crate::Output,
        b: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<MatMulInst> {
        let op = scope.new_operation("MatMul", |builder| {
            builder.add_input(a);
            builder.add_input(b);
            if let ::std::option::Option::Some(value) = &self.transpose_a {
                builder.set_attr_bool("transpose_a", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.transpose_b {
                builder.set_attr_bool("transpose_b", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(MatMulInst { op })
    }
}
impl MatMulInst {
    /// Returns the 'product' Output of this 'MatMul' operation.
    pub fn product(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'a' Input of this 'MatMul' operation.
    pub fn a(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'b' Input of this 'MatMul' operation.
    pub fn b(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<MatMulInst> for crate::Operation {
    fn from(inst: MatMulInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `MatMul::new().build(a, b, scope)`.
pub fn mat_mul<O0: ::std::convert::Into<crate::Output>, O1: ::std::convert::Into<crate::Output>>(
    a: O0,
    b: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    MatMul::new().build(a, b, scope)
}

/// Builder for the `MatchingFiles` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct MatchingFiles {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'MatchingFiles' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct MatchingFilesInst {
    /// An instance of a fully built MatchingFiles Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl MatchingFiles {
    /// Creates a new `MatchingFiles`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `MatchingFiles` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        pattern: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(pattern.into(), scope)
    }
    fn build_impl(
        &self,
        pattern: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("MatchingFiles", |nd| {
            nd.add_input(pattern);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'MatchingFiles' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        pattern: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<MatchingFilesInst> {
        let op = scope.new_operation("MatchingFiles", |builder| {
            builder.add_input(pattern);
            ::std::result::Result::Ok(())
        })?;
        Ok(MatchingFilesInst { op })
    }
}
impl MatchingFilesInst {
    /// Returns the 'filenames' Output of this 'MatchingFiles' operation.
    pub fn filenames(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'pattern' Input of this 'MatchingFiles' operation.
    pub fn pattern(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<MatchingFilesInst> for crate::Operation {
    fn from(inst: MatchingFilesInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `MatchingFiles::new().build(pattern, scope)`.
pub fn matching_files<O0: ::std::convert::Into<crate::Output>>(
    pattern: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    MatchingFiles::new().build(pattern, scope)
}

/// Builder for the `MatchingFilesDataset` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct MatchingFilesDataset {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'MatchingFilesDataset' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct MatchingFilesDatasetInst {
    /// An instance of a fully built MatchingFilesDataset Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl MatchingFilesDataset {
    /// Creates a new `MatchingFilesDataset`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `MatchingFilesDataset` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        patterns: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(patterns.into(), scope)
    }
    fn build_impl(
        &self,
        patterns: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("MatchingFilesDataset", |nd| {
            nd.add_input(patterns);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'MatchingFilesDataset' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        patterns: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<MatchingFilesDatasetInst> {
        let op = scope.new_operation("MatchingFilesDataset", |builder| {
            builder.add_input(patterns);
            ::std::result::Result::Ok(())
        })?;
        Ok(MatchingFilesDatasetInst { op })
    }
}
impl MatchingFilesDatasetInst {
    /// Returns the 'handle' Output of this 'MatchingFilesDataset' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'patterns' Input of this 'MatchingFilesDataset' operation.
    pub fn patterns(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<MatchingFilesDatasetInst> for crate::Operation {
    fn from(inst: MatchingFilesDatasetInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `MatchingFilesDataset::new().build(patterns, scope)`.
pub fn matching_files_dataset<O0: ::std::convert::Into<crate::Output>>(
    patterns: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    MatchingFilesDataset::new().build(patterns, scope)
}

/// Builder for the `MatrixBandPart` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct MatrixBandPart {
    T: ::std::option::Option<crate::DataType>,
    Tindex: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'MatrixBandPart' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct MatrixBandPartInst {
    /// An instance of a fully built MatrixBandPart Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl MatrixBandPart {
    /// Creates a new `MatrixBandPart`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tindex` attribute.
    pub fn Tindex<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tindex = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `MatrixBandPart` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        num_lower: O1,
        num_upper: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), num_lower.into(), num_upper.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        num_lower: crate::Output,
        num_upper: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("MatrixBandPart", |nd| {
            nd.add_input(input);
            nd.add_input(num_lower);
            nd.add_input(num_upper);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindex {
                nd.set_attr_type("Tindex", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'MatrixBandPart' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        num_lower: crate::Output,
        num_upper: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<MatrixBandPartInst> {
        let op = scope.new_operation("MatrixBandPart", |builder| {
            builder.add_input(input);
            builder.add_input(num_lower);
            builder.add_input(num_upper);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindex {
                builder.set_attr_type("Tindex", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(MatrixBandPartInst { op })
    }
}
impl MatrixBandPartInst {
    /// Returns the 'band' Output of this 'MatrixBandPart' operation.
    pub fn band(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'MatrixBandPart' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'num_lower' Input of this 'MatrixBandPart' operation.
    pub fn num_lower(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'num_upper' Input of this 'MatrixBandPart' operation.
    pub fn num_upper(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<MatrixBandPartInst> for crate::Operation {
    fn from(inst: MatrixBandPartInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `MatrixBandPart::new().build(input, num_lower, num_upper, scope)`.
pub fn matrix_band_part<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    input: O0,
    num_lower: O1,
    num_upper: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    MatrixBandPart::new().build(input, num_lower, num_upper, scope)
}

/// Builder for the `MatrixDeterminant` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct MatrixDeterminant {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'MatrixDeterminant' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct MatrixDeterminantInst {
    /// An instance of a fully built MatrixDeterminant Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl MatrixDeterminant {
    /// Creates a new `MatrixDeterminant`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `MatrixDeterminant` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("MatrixDeterminant", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'MatrixDeterminant' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<MatrixDeterminantInst> {
        let op = scope.new_operation("MatrixDeterminant", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(MatrixDeterminantInst { op })
    }
}
impl MatrixDeterminantInst {
    /// Returns the 'output' Output of this 'MatrixDeterminant' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'MatrixDeterminant' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<MatrixDeterminantInst> for crate::Operation {
    fn from(inst: MatrixDeterminantInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `MatrixDeterminant::new().build(input, scope)`.
pub fn matrix_determinant<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    MatrixDeterminant::new().build(input, scope)
}

/// Builder for the `MatrixDiag` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct MatrixDiag {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'MatrixDiag' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct MatrixDiagInst {
    /// An instance of a fully built MatrixDiag Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl MatrixDiag {
    /// Creates a new `MatrixDiag`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `MatrixDiag` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        diagonal: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(diagonal.into(), scope)
    }
    fn build_impl(
        &self,
        diagonal: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("MatrixDiag", |nd| {
            nd.add_input(diagonal);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'MatrixDiag' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        diagonal: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<MatrixDiagInst> {
        let op = scope.new_operation("MatrixDiag", |builder| {
            builder.add_input(diagonal);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(MatrixDiagInst { op })
    }
}
impl MatrixDiagInst {
    /// Returns the 'output' Output of this 'MatrixDiag' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'diagonal' Input of this 'MatrixDiag' operation.
    pub fn diagonal(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<MatrixDiagInst> for crate::Operation {
    fn from(inst: MatrixDiagInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `MatrixDiag::new().build(diagonal, scope)`.
pub fn matrix_diag<O0: ::std::convert::Into<crate::Output>>(
    diagonal: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    MatrixDiag::new().build(diagonal, scope)
}

/// Builder for the `MatrixDiagPart` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct MatrixDiagPart {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'MatrixDiagPart' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct MatrixDiagPartInst {
    /// An instance of a fully built MatrixDiagPart Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl MatrixDiagPart {
    /// Creates a new `MatrixDiagPart`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `MatrixDiagPart` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("MatrixDiagPart", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'MatrixDiagPart' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<MatrixDiagPartInst> {
        let op = scope.new_operation("MatrixDiagPart", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(MatrixDiagPartInst { op })
    }
}
impl MatrixDiagPartInst {
    /// Returns the 'diagonal' Output of this 'MatrixDiagPart' operation.
    pub fn diagonal(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'MatrixDiagPart' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<MatrixDiagPartInst> for crate::Operation {
    fn from(inst: MatrixDiagPartInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `MatrixDiagPart::new().build(input, scope)`.
pub fn matrix_diag_part<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    MatrixDiagPart::new().build(input, scope)
}

/// Builder for the `MatrixDiagPartV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct MatrixDiagPartV2 {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'MatrixDiagPartV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct MatrixDiagPartV2Inst {
    /// An instance of a fully built MatrixDiagPartV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl MatrixDiagPartV2 {
    /// Creates a new `MatrixDiagPartV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `MatrixDiagPartV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        k: O1,
        padding_value: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), k.into(), padding_value.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        k: crate::Output,
        padding_value: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("MatrixDiagPartV2", |nd| {
            nd.add_input(input);
            nd.add_input(k);
            nd.add_input(padding_value);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'MatrixDiagPartV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        k: crate::Output,
        padding_value: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<MatrixDiagPartV2Inst> {
        let op = scope.new_operation("MatrixDiagPartV2", |builder| {
            builder.add_input(input);
            builder.add_input(k);
            builder.add_input(padding_value);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(MatrixDiagPartV2Inst { op })
    }
}
impl MatrixDiagPartV2Inst {
    /// Returns the 'diagonal' Output of this 'MatrixDiagPartV2' operation.
    pub fn diagonal(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'MatrixDiagPartV2' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'k' Input of this 'MatrixDiagPartV2' operation.
    pub fn k(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'padding_value' Input of this 'MatrixDiagPartV2' operation.
    pub fn padding_value(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<MatrixDiagPartV2Inst> for crate::Operation {
    fn from(inst: MatrixDiagPartV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `MatrixDiagPartV2::new().build(input, k, padding_value, scope)`.
pub fn matrix_diag_part_v2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    input: O0,
    k: O1,
    padding_value: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    MatrixDiagPartV2::new().build(input, k, padding_value, scope)
}

/// Builder for the `MatrixDiagPartV3` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct MatrixDiagPartV3 {
    T: ::std::option::Option<crate::DataType>,
    align: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'MatrixDiagPartV3' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct MatrixDiagPartV3Inst {
    /// An instance of a fully built MatrixDiagPartV3 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl MatrixDiagPartV3 {
    /// Creates a new `MatrixDiagPartV3`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `align` attribute.
    pub fn align<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.align = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `MatrixDiagPartV3` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        k: O1,
        padding_value: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), k.into(), padding_value.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        k: crate::Output,
        padding_value: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("MatrixDiagPartV3", |nd| {
            nd.add_input(input);
            nd.add_input(k);
            nd.add_input(padding_value);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.align {
                nd.set_attr_string("align", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'MatrixDiagPartV3' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        k: crate::Output,
        padding_value: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<MatrixDiagPartV3Inst> {
        let op = scope.new_operation("MatrixDiagPartV3", |builder| {
            builder.add_input(input);
            builder.add_input(k);
            builder.add_input(padding_value);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.align {
                builder.set_attr_string("align", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(MatrixDiagPartV3Inst { op })
    }
}
impl MatrixDiagPartV3Inst {
    /// Returns the 'diagonal' Output of this 'MatrixDiagPartV3' operation.
    pub fn diagonal(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'MatrixDiagPartV3' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'k' Input of this 'MatrixDiagPartV3' operation.
    pub fn k(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'padding_value' Input of this 'MatrixDiagPartV3' operation.
    pub fn padding_value(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<MatrixDiagPartV3Inst> for crate::Operation {
    fn from(inst: MatrixDiagPartV3Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `MatrixDiagPartV3::new().build(input, k, padding_value, scope)`.
pub fn matrix_diag_part_v3<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    input: O0,
    k: O1,
    padding_value: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    MatrixDiagPartV3::new().build(input, k, padding_value, scope)
}

/// Builder for the `MatrixDiagV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct MatrixDiagV2 {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'MatrixDiagV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct MatrixDiagV2Inst {
    /// An instance of a fully built MatrixDiagV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl MatrixDiagV2 {
    /// Creates a new `MatrixDiagV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `MatrixDiagV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
    >(
        &self,
        diagonal: O0,
        k: O1,
        num_rows: O2,
        num_cols: O3,
        padding_value: O4,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            diagonal.into(),
            k.into(),
            num_rows.into(),
            num_cols.into(),
            padding_value.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        diagonal: crate::Output,
        k: crate::Output,
        num_rows: crate::Output,
        num_cols: crate::Output,
        padding_value: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("MatrixDiagV2", |nd| {
            nd.add_input(diagonal);
            nd.add_input(k);
            nd.add_input(num_rows);
            nd.add_input(num_cols);
            nd.add_input(padding_value);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'MatrixDiagV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        diagonal: crate::Output,
        k: crate::Output,
        num_rows: crate::Output,
        num_cols: crate::Output,
        padding_value: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<MatrixDiagV2Inst> {
        let op = scope.new_operation("MatrixDiagV2", |builder| {
            builder.add_input(diagonal);
            builder.add_input(k);
            builder.add_input(num_rows);
            builder.add_input(num_cols);
            builder.add_input(padding_value);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(MatrixDiagV2Inst { op })
    }
}
impl MatrixDiagV2Inst {
    /// Returns the 'output' Output of this 'MatrixDiagV2' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'diagonal' Input of this 'MatrixDiagV2' operation.
    pub fn diagonal(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'k' Input of this 'MatrixDiagV2' operation.
    pub fn k(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'num_rows' Input of this 'MatrixDiagV2' operation.
    pub fn num_rows(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'num_cols' Input of this 'MatrixDiagV2' operation.
    pub fn num_cols(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'padding_value' Input of this 'MatrixDiagV2' operation.
    pub fn padding_value(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
}
impl From<MatrixDiagV2Inst> for crate::Operation {
    fn from(inst: MatrixDiagV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `MatrixDiagV2::new().build(diagonal, k, num_rows, num_cols, padding_value, scope)`.
pub fn matrix_diag_v2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
>(
    diagonal: O0,
    k: O1,
    num_rows: O2,
    num_cols: O3,
    padding_value: O4,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    MatrixDiagV2::new().build(diagonal, k, num_rows, num_cols, padding_value, scope)
}

/// Builder for the `MatrixDiagV3` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct MatrixDiagV3 {
    T: ::std::option::Option<crate::DataType>,
    align: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'MatrixDiagV3' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct MatrixDiagV3Inst {
    /// An instance of a fully built MatrixDiagV3 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl MatrixDiagV3 {
    /// Creates a new `MatrixDiagV3`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `align` attribute.
    pub fn align<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.align = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `MatrixDiagV3` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
    >(
        &self,
        diagonal: O0,
        k: O1,
        num_rows: O2,
        num_cols: O3,
        padding_value: O4,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            diagonal.into(),
            k.into(),
            num_rows.into(),
            num_cols.into(),
            padding_value.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        diagonal: crate::Output,
        k: crate::Output,
        num_rows: crate::Output,
        num_cols: crate::Output,
        padding_value: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("MatrixDiagV3", |nd| {
            nd.add_input(diagonal);
            nd.add_input(k);
            nd.add_input(num_rows);
            nd.add_input(num_cols);
            nd.add_input(padding_value);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.align {
                nd.set_attr_string("align", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'MatrixDiagV3' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        diagonal: crate::Output,
        k: crate::Output,
        num_rows: crate::Output,
        num_cols: crate::Output,
        padding_value: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<MatrixDiagV3Inst> {
        let op = scope.new_operation("MatrixDiagV3", |builder| {
            builder.add_input(diagonal);
            builder.add_input(k);
            builder.add_input(num_rows);
            builder.add_input(num_cols);
            builder.add_input(padding_value);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.align {
                builder.set_attr_string("align", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(MatrixDiagV3Inst { op })
    }
}
impl MatrixDiagV3Inst {
    /// Returns the 'output' Output of this 'MatrixDiagV3' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'diagonal' Input of this 'MatrixDiagV3' operation.
    pub fn diagonal(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'k' Input of this 'MatrixDiagV3' operation.
    pub fn k(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'num_rows' Input of this 'MatrixDiagV3' operation.
    pub fn num_rows(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'num_cols' Input of this 'MatrixDiagV3' operation.
    pub fn num_cols(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'padding_value' Input of this 'MatrixDiagV3' operation.
    pub fn padding_value(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
}
impl From<MatrixDiagV3Inst> for crate::Operation {
    fn from(inst: MatrixDiagV3Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `MatrixDiagV3::new().build(diagonal, k, num_rows, num_cols, padding_value, scope)`.
pub fn matrix_diag_v3<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
>(
    diagonal: O0,
    k: O1,
    num_rows: O2,
    num_cols: O3,
    padding_value: O4,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    MatrixDiagV3::new().build(diagonal, k, num_rows, num_cols, padding_value, scope)
}

/// Builder for the `MatrixExponential` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct MatrixExponential {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'MatrixExponential' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct MatrixExponentialInst {
    /// An instance of a fully built MatrixExponential Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl MatrixExponential {
    /// Creates a new `MatrixExponential`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `MatrixExponential` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("MatrixExponential", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'MatrixExponential' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<MatrixExponentialInst> {
        let op = scope.new_operation("MatrixExponential", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(MatrixExponentialInst { op })
    }
}
impl MatrixExponentialInst {
    /// Returns the 'output' Output of this 'MatrixExponential' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'MatrixExponential' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<MatrixExponentialInst> for crate::Operation {
    fn from(inst: MatrixExponentialInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `MatrixExponential::new().build(input, scope)`.
pub fn matrix_exponential<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    MatrixExponential::new().build(input, scope)
}

/// Builder for the `MatrixInverse` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct MatrixInverse {
    adjoint: ::std::option::Option<bool>,
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'MatrixInverse' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct MatrixInverseInst {
    /// An instance of a fully built MatrixInverse Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl MatrixInverse {
    /// Creates a new `MatrixInverse`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `adjoint` attribute.
    pub fn adjoint<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.adjoint = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `MatrixInverse` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("MatrixInverse", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.adjoint {
                nd.set_attr_bool("adjoint", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'MatrixInverse' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<MatrixInverseInst> {
        let op = scope.new_operation("MatrixInverse", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.adjoint {
                builder.set_attr_bool("adjoint", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(MatrixInverseInst { op })
    }
}
impl MatrixInverseInst {
    /// Returns the 'output' Output of this 'MatrixInverse' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'MatrixInverse' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<MatrixInverseInst> for crate::Operation {
    fn from(inst: MatrixInverseInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `MatrixInverse::new().build(input, scope)`.
pub fn matrix_inverse<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    MatrixInverse::new().build(input, scope)
}

/// Builder for the `MatrixLogarithm` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct MatrixLogarithm {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'MatrixLogarithm' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct MatrixLogarithmInst {
    /// An instance of a fully built MatrixLogarithm Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl MatrixLogarithm {
    /// Creates a new `MatrixLogarithm`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `MatrixLogarithm` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("MatrixLogarithm", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'MatrixLogarithm' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<MatrixLogarithmInst> {
        let op = scope.new_operation("MatrixLogarithm", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(MatrixLogarithmInst { op })
    }
}
impl MatrixLogarithmInst {
    /// Returns the 'output' Output of this 'MatrixLogarithm' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'MatrixLogarithm' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<MatrixLogarithmInst> for crate::Operation {
    fn from(inst: MatrixLogarithmInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `MatrixLogarithm::new().build(input, scope)`.
pub fn matrix_logarithm<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    MatrixLogarithm::new().build(input, scope)
}

/// Builder for the `MatrixSetDiag` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct MatrixSetDiag {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'MatrixSetDiag' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct MatrixSetDiagInst {
    /// An instance of a fully built MatrixSetDiag Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl MatrixSetDiag {
    /// Creates a new `MatrixSetDiag`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `MatrixSetDiag` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        diagonal: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), diagonal.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        diagonal: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("MatrixSetDiag", |nd| {
            nd.add_input(input);
            nd.add_input(diagonal);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'MatrixSetDiag' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        diagonal: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<MatrixSetDiagInst> {
        let op = scope.new_operation("MatrixSetDiag", |builder| {
            builder.add_input(input);
            builder.add_input(diagonal);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(MatrixSetDiagInst { op })
    }
}
impl MatrixSetDiagInst {
    /// Returns the 'output' Output of this 'MatrixSetDiag' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'MatrixSetDiag' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'diagonal' Input of this 'MatrixSetDiag' operation.
    pub fn diagonal(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<MatrixSetDiagInst> for crate::Operation {
    fn from(inst: MatrixSetDiagInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `MatrixSetDiag::new().build(input, diagonal, scope)`.
pub fn matrix_set_diag<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    input: O0,
    diagonal: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    MatrixSetDiag::new().build(input, diagonal, scope)
}

/// Builder for the `MatrixSetDiagV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct MatrixSetDiagV2 {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'MatrixSetDiagV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct MatrixSetDiagV2Inst {
    /// An instance of a fully built MatrixSetDiagV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl MatrixSetDiagV2 {
    /// Creates a new `MatrixSetDiagV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `MatrixSetDiagV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        diagonal: O1,
        k: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), diagonal.into(), k.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        diagonal: crate::Output,
        k: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("MatrixSetDiagV2", |nd| {
            nd.add_input(input);
            nd.add_input(diagonal);
            nd.add_input(k);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'MatrixSetDiagV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        diagonal: crate::Output,
        k: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<MatrixSetDiagV2Inst> {
        let op = scope.new_operation("MatrixSetDiagV2", |builder| {
            builder.add_input(input);
            builder.add_input(diagonal);
            builder.add_input(k);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(MatrixSetDiagV2Inst { op })
    }
}
impl MatrixSetDiagV2Inst {
    /// Returns the 'output' Output of this 'MatrixSetDiagV2' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'MatrixSetDiagV2' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'diagonal' Input of this 'MatrixSetDiagV2' operation.
    pub fn diagonal(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'k' Input of this 'MatrixSetDiagV2' operation.
    pub fn k(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<MatrixSetDiagV2Inst> for crate::Operation {
    fn from(inst: MatrixSetDiagV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `MatrixSetDiagV2::new().build(input, diagonal, k, scope)`.
pub fn matrix_set_diag_v2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    input: O0,
    diagonal: O1,
    k: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    MatrixSetDiagV2::new().build(input, diagonal, k, scope)
}

/// Builder for the `MatrixSetDiagV3` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct MatrixSetDiagV3 {
    T: ::std::option::Option<crate::DataType>,
    align: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'MatrixSetDiagV3' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct MatrixSetDiagV3Inst {
    /// An instance of a fully built MatrixSetDiagV3 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl MatrixSetDiagV3 {
    /// Creates a new `MatrixSetDiagV3`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `align` attribute.
    pub fn align<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.align = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `MatrixSetDiagV3` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        diagonal: O1,
        k: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), diagonal.into(), k.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        diagonal: crate::Output,
        k: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("MatrixSetDiagV3", |nd| {
            nd.add_input(input);
            nd.add_input(diagonal);
            nd.add_input(k);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.align {
                nd.set_attr_string("align", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'MatrixSetDiagV3' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        diagonal: crate::Output,
        k: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<MatrixSetDiagV3Inst> {
        let op = scope.new_operation("MatrixSetDiagV3", |builder| {
            builder.add_input(input);
            builder.add_input(diagonal);
            builder.add_input(k);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.align {
                builder.set_attr_string("align", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(MatrixSetDiagV3Inst { op })
    }
}
impl MatrixSetDiagV3Inst {
    /// Returns the 'output' Output of this 'MatrixSetDiagV3' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'MatrixSetDiagV3' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'diagonal' Input of this 'MatrixSetDiagV3' operation.
    pub fn diagonal(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'k' Input of this 'MatrixSetDiagV3' operation.
    pub fn k(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<MatrixSetDiagV3Inst> for crate::Operation {
    fn from(inst: MatrixSetDiagV3Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `MatrixSetDiagV3::new().build(input, diagonal, k, scope)`.
pub fn matrix_set_diag_v3<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    input: O0,
    diagonal: O1,
    k: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    MatrixSetDiagV3::new().build(input, diagonal, k, scope)
}

/// Builder for the `MatrixSolve` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct MatrixSolve {
    adjoint: ::std::option::Option<bool>,
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'MatrixSolve' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct MatrixSolveInst {
    /// An instance of a fully built MatrixSolve Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl MatrixSolve {
    /// Creates a new `MatrixSolve`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `adjoint` attribute.
    pub fn adjoint<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.adjoint = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `MatrixSolve` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        matrix: O0,
        rhs: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(matrix.into(), rhs.into(), scope)
    }
    fn build_impl(
        &self,
        matrix: crate::Output,
        rhs: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("MatrixSolve", |nd| {
            nd.add_input(matrix);
            nd.add_input(rhs);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.adjoint {
                nd.set_attr_bool("adjoint", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'MatrixSolve' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        matrix: crate::Output,
        rhs: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<MatrixSolveInst> {
        let op = scope.new_operation("MatrixSolve", |builder| {
            builder.add_input(matrix);
            builder.add_input(rhs);
            if let ::std::option::Option::Some(value) = &self.adjoint {
                builder.set_attr_bool("adjoint", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(MatrixSolveInst { op })
    }
}
impl MatrixSolveInst {
    /// Returns the 'output' Output of this 'MatrixSolve' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'matrix' Input of this 'MatrixSolve' operation.
    pub fn matrix(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'rhs' Input of this 'MatrixSolve' operation.
    pub fn rhs(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<MatrixSolveInst> for crate::Operation {
    fn from(inst: MatrixSolveInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `MatrixSolve::new().build(matrix, rhs, scope)`.
pub fn matrix_solve<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    matrix: O0,
    rhs: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    MatrixSolve::new().build(matrix, rhs, scope)
}

/// Builder for the `MatrixSolveLs` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct MatrixSolveLs {
    T: ::std::option::Option<crate::DataType>,
    fast: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'MatrixSolveLs' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct MatrixSolveLsInst {
    /// An instance of a fully built MatrixSolveLs Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl MatrixSolveLs {
    /// Creates a new `MatrixSolveLs`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `fast` attribute.
    pub fn fast<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.fast = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `MatrixSolveLs` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        matrix: O0,
        rhs: O1,
        l2_regularizer: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(matrix.into(), rhs.into(), l2_regularizer.into(), scope)
    }
    fn build_impl(
        &self,
        matrix: crate::Output,
        rhs: crate::Output,
        l2_regularizer: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("MatrixSolveLs", |nd| {
            nd.add_input(matrix);
            nd.add_input(rhs);
            nd.add_input(l2_regularizer);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.fast {
                nd.set_attr_bool("fast", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'MatrixSolveLs' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        matrix: crate::Output,
        rhs: crate::Output,
        l2_regularizer: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<MatrixSolveLsInst> {
        let op = scope.new_operation("MatrixSolveLs", |builder| {
            builder.add_input(matrix);
            builder.add_input(rhs);
            builder.add_input(l2_regularizer);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.fast {
                builder.set_attr_bool("fast", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(MatrixSolveLsInst { op })
    }
}
impl MatrixSolveLsInst {
    /// Returns the 'output' Output of this 'MatrixSolveLs' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'matrix' Input of this 'MatrixSolveLs' operation.
    pub fn matrix(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'rhs' Input of this 'MatrixSolveLs' operation.
    pub fn rhs(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'l2_regularizer' Input of this 'MatrixSolveLs' operation.
    pub fn l2_regularizer(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<MatrixSolveLsInst> for crate::Operation {
    fn from(inst: MatrixSolveLsInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `MatrixSolveLs::new().build(matrix, rhs, l2_regularizer, scope)`.
pub fn matrix_solve_ls<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    matrix: O0,
    rhs: O1,
    l2_regularizer: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    MatrixSolveLs::new().build(matrix, rhs, l2_regularizer, scope)
}

/// Builder for the `MatrixSquareRoot` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct MatrixSquareRoot {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'MatrixSquareRoot' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct MatrixSquareRootInst {
    /// An instance of a fully built MatrixSquareRoot Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl MatrixSquareRoot {
    /// Creates a new `MatrixSquareRoot`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `MatrixSquareRoot` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("MatrixSquareRoot", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'MatrixSquareRoot' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<MatrixSquareRootInst> {
        let op = scope.new_operation("MatrixSquareRoot", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(MatrixSquareRootInst { op })
    }
}
impl MatrixSquareRootInst {
    /// Returns the 'output' Output of this 'MatrixSquareRoot' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'MatrixSquareRoot' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<MatrixSquareRootInst> for crate::Operation {
    fn from(inst: MatrixSquareRootInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `MatrixSquareRoot::new().build(input, scope)`.
pub fn matrix_square_root<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    MatrixSquareRoot::new().build(input, scope)
}

/// Builder for the `MatrixTriangularSolve` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct MatrixTriangularSolve {
    lower: ::std::option::Option<bool>,
    adjoint: ::std::option::Option<bool>,
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'MatrixTriangularSolve' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct MatrixTriangularSolveInst {
    /// An instance of a fully built MatrixTriangularSolve Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl MatrixTriangularSolve {
    /// Creates a new `MatrixTriangularSolve`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `lower` attribute.
    pub fn lower<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.lower = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `adjoint` attribute.
    pub fn adjoint<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.adjoint = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `MatrixTriangularSolve` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        matrix: O0,
        rhs: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(matrix.into(), rhs.into(), scope)
    }
    fn build_impl(
        &self,
        matrix: crate::Output,
        rhs: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("MatrixTriangularSolve", |nd| {
            nd.add_input(matrix);
            nd.add_input(rhs);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.lower {
                nd.set_attr_bool("lower", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.adjoint {
                nd.set_attr_bool("adjoint", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'MatrixTriangularSolve' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        matrix: crate::Output,
        rhs: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<MatrixTriangularSolveInst> {
        let op = scope.new_operation("MatrixTriangularSolve", |builder| {
            builder.add_input(matrix);
            builder.add_input(rhs);
            if let ::std::option::Option::Some(value) = &self.lower {
                builder.set_attr_bool("lower", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.adjoint {
                builder.set_attr_bool("adjoint", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(MatrixTriangularSolveInst { op })
    }
}
impl MatrixTriangularSolveInst {
    /// Returns the 'output' Output of this 'MatrixTriangularSolve' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'matrix' Input of this 'MatrixTriangularSolve' operation.
    pub fn matrix(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'rhs' Input of this 'MatrixTriangularSolve' operation.
    pub fn rhs(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<MatrixTriangularSolveInst> for crate::Operation {
    fn from(inst: MatrixTriangularSolveInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `MatrixTriangularSolve::new().build(matrix, rhs, scope)`.
pub fn matrix_triangular_solve<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    matrix: O0,
    rhs: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    MatrixTriangularSolve::new().build(matrix, rhs, scope)
}

/// Builder for the `Max` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Max {
    keep_dims: ::std::option::Option<bool>,
    T: ::std::option::Option<crate::DataType>,
    Tidx: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Max' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct MaxInst {
    /// An instance of a fully built Max Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Max {
    /// Creates a new `Max`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `keep_dims` attribute.
    pub fn keep_dims<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.keep_dims = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tidx` attribute.
    pub fn Tidx<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Tidx = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Max` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        reduction_indices: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), reduction_indices.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        reduction_indices: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Max", |nd| {
            nd.add_input(input);
            nd.add_input(reduction_indices);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.keep_dims {
                nd.set_attr_bool("keep_dims", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tidx {
                nd.set_attr_type("Tidx", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Max' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        reduction_indices: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<MaxInst> {
        let op = scope.new_operation("Max", |builder| {
            builder.add_input(input);
            builder.add_input(reduction_indices);
            if let ::std::option::Option::Some(value) = &self.keep_dims {
                builder.set_attr_bool("keep_dims", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tidx {
                builder.set_attr_type("Tidx", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(MaxInst { op })
    }
}
impl MaxInst {
    /// Returns the 'output' Output of this 'Max' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'Max' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'reduction_indices' Input of this 'Max' operation.
    pub fn reduction_indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<MaxInst> for crate::Operation {
    fn from(inst: MaxInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Max::new().build(input, reduction_indices, scope)`.
pub fn max<O0: ::std::convert::Into<crate::Output>, O1: ::std::convert::Into<crate::Output>>(
    input: O0,
    reduction_indices: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Max::new().build(input, reduction_indices, scope)
}

/// Builder for the `MaxIntraOpParallelismDataset` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct MaxIntraOpParallelismDataset {
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'MaxIntraOpParallelismDataset' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct MaxIntraOpParallelismDatasetInst {
    /// An instance of a fully built MaxIntraOpParallelismDataset Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl MaxIntraOpParallelismDataset {
    /// Creates a new `MaxIntraOpParallelismDataset`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `MaxIntraOpParallelismDataset` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input_dataset: O0,
        max_intra_op_parallelism: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input_dataset.into(), max_intra_op_parallelism.into(), scope)
    }
    fn build_impl(
        &self,
        input_dataset: crate::Output,
        max_intra_op_parallelism: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("MaxIntraOpParallelismDataset", |nd| {
            nd.add_input(input_dataset);
            nd.add_input(max_intra_op_parallelism);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'MaxIntraOpParallelismDataset' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_dataset: crate::Output,
        max_intra_op_parallelism: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<MaxIntraOpParallelismDatasetInst> {
        let op = scope.new_operation("MaxIntraOpParallelismDataset", |builder| {
            builder.add_input(input_dataset);
            builder.add_input(max_intra_op_parallelism);
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(MaxIntraOpParallelismDatasetInst { op })
    }
}
impl MaxIntraOpParallelismDatasetInst {
    /// Returns the 'handle' Output of this 'MaxIntraOpParallelismDataset' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_dataset' Input of this 'MaxIntraOpParallelismDataset' operation.
    pub fn input_dataset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'max_intra_op_parallelism' Input of this 'MaxIntraOpParallelismDataset' operation.
    pub fn max_intra_op_parallelism(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<MaxIntraOpParallelismDatasetInst> for crate::Operation {
    fn from(inst: MaxIntraOpParallelismDatasetInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `MaxIntraOpParallelismDataset::new().build(input_dataset, max_intra_op_parallelism, scope)`.
pub fn max_intra_op_parallelism_dataset<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    input_dataset: O0,
    max_intra_op_parallelism: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    MaxIntraOpParallelismDataset::new().build(input_dataset, max_intra_op_parallelism, scope)
}

/// Builder for the `MaxPool` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct MaxPool {
    T: ::std::option::Option<crate::DataType>,
    ksize: ::std::option::Option<::std::vec::Vec<i64>>,
    strides: ::std::option::Option<::std::vec::Vec<i64>>,
    padding: ::std::option::Option<::std::string::String>,
    explicit_paddings: ::std::option::Option<::std::vec::Vec<i64>>,
    data_format: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'MaxPool' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct MaxPoolInst {
    /// An instance of a fully built MaxPool Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl MaxPool {
    /// Creates a new `MaxPool`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `ksize` attribute.
    pub fn ksize<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.ksize = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `strides` attribute.
    pub fn strides<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.strides = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `padding` attribute.
    pub fn padding<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.padding = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `explicit_paddings` attribute.
    pub fn explicit_paddings<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.explicit_paddings = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `data_format` attribute.
    pub fn data_format<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.data_format = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `MaxPool` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("MaxPool", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.ksize {
                nd.set_attr_int_list("ksize", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.strides {
                nd.set_attr_int_list("strides", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding {
                nd.set_attr_string("padding", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.explicit_paddings {
                nd.set_attr_int_list("explicit_paddings", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.data_format {
                nd.set_attr_string("data_format", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'MaxPool' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<MaxPoolInst> {
        let op = scope.new_operation("MaxPool", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.ksize {
                builder.set_attr_int_list("ksize", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.strides {
                builder.set_attr_int_list("strides", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding {
                builder.set_attr_string("padding", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.explicit_paddings {
                builder.set_attr_int_list("explicit_paddings", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.data_format {
                builder.set_attr_string("data_format", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(MaxPoolInst { op })
    }
}
impl MaxPoolInst {
    /// Returns the 'output' Output of this 'MaxPool' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'MaxPool' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<MaxPoolInst> for crate::Operation {
    fn from(inst: MaxPoolInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `MaxPool::new().build(input, scope)`.
pub fn max_pool<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    MaxPool::new().build(input, scope)
}

/// Builder for the `MaxPool3D` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct MaxPool3D {
    ksize: ::std::option::Option<::std::vec::Vec<i64>>,
    strides: ::std::option::Option<::std::vec::Vec<i64>>,
    padding: ::std::option::Option<::std::string::String>,
    data_format: ::std::option::Option<::std::string::String>,
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'MaxPool3D' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct MaxPool3DInst {
    /// An instance of a fully built MaxPool3D Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl MaxPool3D {
    /// Creates a new `MaxPool3D`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `ksize` attribute.
    pub fn ksize<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.ksize = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `strides` attribute.
    pub fn strides<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.strides = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `padding` attribute.
    pub fn padding<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.padding = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `data_format` attribute.
    pub fn data_format<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.data_format = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `MaxPool3D` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("MaxPool3D", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.ksize {
                nd.set_attr_int_list("ksize", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.strides {
                nd.set_attr_int_list("strides", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding {
                nd.set_attr_string("padding", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.data_format {
                nd.set_attr_string("data_format", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'MaxPool3D' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<MaxPool3DInst> {
        let op = scope.new_operation("MaxPool3D", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.ksize {
                builder.set_attr_int_list("ksize", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.strides {
                builder.set_attr_int_list("strides", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding {
                builder.set_attr_string("padding", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.data_format {
                builder.set_attr_string("data_format", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(MaxPool3DInst { op })
    }
}
impl MaxPool3DInst {
    /// Returns the 'output' Output of this 'MaxPool3D' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'MaxPool3D' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<MaxPool3DInst> for crate::Operation {
    fn from(inst: MaxPool3DInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `MaxPool3D::new().build(input, scope)`.
pub fn max_pool3_d<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    MaxPool3D::new().build(input, scope)
}

/// Builder for the `MaxPool3DGrad` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct MaxPool3DGrad {
    ksize: ::std::option::Option<::std::vec::Vec<i64>>,
    strides: ::std::option::Option<::std::vec::Vec<i64>>,
    padding: ::std::option::Option<::std::string::String>,
    data_format: ::std::option::Option<::std::string::String>,
    T: ::std::option::Option<crate::DataType>,
    TInput: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'MaxPool3DGrad' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct MaxPool3DGradInst {
    /// An instance of a fully built MaxPool3DGrad Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl MaxPool3DGrad {
    /// Creates a new `MaxPool3DGrad`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `ksize` attribute.
    pub fn ksize<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.ksize = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `strides` attribute.
    pub fn strides<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.strides = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `padding` attribute.
    pub fn padding<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.padding = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `data_format` attribute.
    pub fn data_format<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.data_format = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `TInput` attribute.
    pub fn TInput<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.TInput = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `MaxPool3DGrad` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        orig_input: O0,
        orig_output: O1,
        grad: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(orig_input.into(), orig_output.into(), grad.into(), scope)
    }
    fn build_impl(
        &self,
        orig_input: crate::Output,
        orig_output: crate::Output,
        grad: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("MaxPool3DGrad", |nd| {
            nd.add_input(orig_input);
            nd.add_input(orig_output);
            nd.add_input(grad);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.ksize {
                nd.set_attr_int_list("ksize", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.strides {
                nd.set_attr_int_list("strides", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding {
                nd.set_attr_string("padding", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.data_format {
                nd.set_attr_string("data_format", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.TInput {
                nd.set_attr_type("TInput", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'MaxPool3DGrad' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        orig_input: crate::Output,
        orig_output: crate::Output,
        grad: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<MaxPool3DGradInst> {
        let op = scope.new_operation("MaxPool3DGrad", |builder| {
            builder.add_input(orig_input);
            builder.add_input(orig_output);
            builder.add_input(grad);
            if let ::std::option::Option::Some(value) = &self.ksize {
                builder.set_attr_int_list("ksize", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.strides {
                builder.set_attr_int_list("strides", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding {
                builder.set_attr_string("padding", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.data_format {
                builder.set_attr_string("data_format", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.TInput {
                builder.set_attr_type("TInput", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(MaxPool3DGradInst { op })
    }
}
impl MaxPool3DGradInst {
    /// Returns the 'output' Output of this 'MaxPool3DGrad' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'orig_input' Input of this 'MaxPool3DGrad' operation.
    pub fn orig_input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'orig_output' Input of this 'MaxPool3DGrad' operation.
    pub fn orig_output(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'grad' Input of this 'MaxPool3DGrad' operation.
    pub fn grad(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<MaxPool3DGradInst> for crate::Operation {
    fn from(inst: MaxPool3DGradInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `MaxPool3DGrad::new().build(orig_input, orig_output, grad, scope)`.
pub fn max_pool3_dgrad<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    orig_input: O0,
    orig_output: O1,
    grad: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    MaxPool3DGrad::new().build(orig_input, orig_output, grad, scope)
}

/// Builder for the `MaxPool3DGradGrad` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct MaxPool3DGradGrad {
    ksize: ::std::option::Option<::std::vec::Vec<i64>>,
    strides: ::std::option::Option<::std::vec::Vec<i64>>,
    padding: ::std::option::Option<::std::string::String>,
    data_format: ::std::option::Option<::std::string::String>,
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'MaxPool3DGradGrad' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct MaxPool3DGradGradInst {
    /// An instance of a fully built MaxPool3DGradGrad Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl MaxPool3DGradGrad {
    /// Creates a new `MaxPool3DGradGrad`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `ksize` attribute.
    pub fn ksize<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.ksize = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `strides` attribute.
    pub fn strides<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.strides = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `padding` attribute.
    pub fn padding<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.padding = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `data_format` attribute.
    pub fn data_format<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.data_format = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `MaxPool3DGradGrad` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        orig_input: O0,
        orig_output: O1,
        grad: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(orig_input.into(), orig_output.into(), grad.into(), scope)
    }
    fn build_impl(
        &self,
        orig_input: crate::Output,
        orig_output: crate::Output,
        grad: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("MaxPool3DGradGrad", |nd| {
            nd.add_input(orig_input);
            nd.add_input(orig_output);
            nd.add_input(grad);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.ksize {
                nd.set_attr_int_list("ksize", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.strides {
                nd.set_attr_int_list("strides", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding {
                nd.set_attr_string("padding", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.data_format {
                nd.set_attr_string("data_format", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'MaxPool3DGradGrad' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        orig_input: crate::Output,
        orig_output: crate::Output,
        grad: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<MaxPool3DGradGradInst> {
        let op = scope.new_operation("MaxPool3DGradGrad", |builder| {
            builder.add_input(orig_input);
            builder.add_input(orig_output);
            builder.add_input(grad);
            if let ::std::option::Option::Some(value) = &self.ksize {
                builder.set_attr_int_list("ksize", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.strides {
                builder.set_attr_int_list("strides", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding {
                builder.set_attr_string("padding", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.data_format {
                builder.set_attr_string("data_format", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(MaxPool3DGradGradInst { op })
    }
}
impl MaxPool3DGradGradInst {
    /// Returns the 'output' Output of this 'MaxPool3DGradGrad' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'orig_input' Input of this 'MaxPool3DGradGrad' operation.
    pub fn orig_input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'orig_output' Input of this 'MaxPool3DGradGrad' operation.
    pub fn orig_output(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'grad' Input of this 'MaxPool3DGradGrad' operation.
    pub fn grad(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<MaxPool3DGradGradInst> for crate::Operation {
    fn from(inst: MaxPool3DGradGradInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `MaxPool3DGradGrad::new().build(orig_input, orig_output, grad, scope)`.
pub fn max_pool3_dgrad_grad<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    orig_input: O0,
    orig_output: O1,
    grad: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    MaxPool3DGradGrad::new().build(orig_input, orig_output, grad, scope)
}

/// Builder for the `MaxPoolGrad` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct MaxPoolGrad {
    ksize: ::std::option::Option<::std::vec::Vec<i64>>,
    strides: ::std::option::Option<::std::vec::Vec<i64>>,
    padding: ::std::option::Option<::std::string::String>,
    explicit_paddings: ::std::option::Option<::std::vec::Vec<i64>>,
    data_format: ::std::option::Option<::std::string::String>,
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'MaxPoolGrad' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct MaxPoolGradInst {
    /// An instance of a fully built MaxPoolGrad Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl MaxPoolGrad {
    /// Creates a new `MaxPoolGrad`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `ksize` attribute.
    pub fn ksize<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.ksize = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `strides` attribute.
    pub fn strides<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.strides = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `padding` attribute.
    pub fn padding<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.padding = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `explicit_paddings` attribute.
    pub fn explicit_paddings<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.explicit_paddings = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `data_format` attribute.
    pub fn data_format<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.data_format = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `MaxPoolGrad` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        orig_input: O0,
        orig_output: O1,
        grad: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(orig_input.into(), orig_output.into(), grad.into(), scope)
    }
    fn build_impl(
        &self,
        orig_input: crate::Output,
        orig_output: crate::Output,
        grad: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("MaxPoolGrad", |nd| {
            nd.add_input(orig_input);
            nd.add_input(orig_output);
            nd.add_input(grad);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.ksize {
                nd.set_attr_int_list("ksize", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.strides {
                nd.set_attr_int_list("strides", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding {
                nd.set_attr_string("padding", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.explicit_paddings {
                nd.set_attr_int_list("explicit_paddings", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.data_format {
                nd.set_attr_string("data_format", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'MaxPoolGrad' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        orig_input: crate::Output,
        orig_output: crate::Output,
        grad: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<MaxPoolGradInst> {
        let op = scope.new_operation("MaxPoolGrad", |builder| {
            builder.add_input(orig_input);
            builder.add_input(orig_output);
            builder.add_input(grad);
            if let ::std::option::Option::Some(value) = &self.ksize {
                builder.set_attr_int_list("ksize", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.strides {
                builder.set_attr_int_list("strides", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding {
                builder.set_attr_string("padding", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.explicit_paddings {
                builder.set_attr_int_list("explicit_paddings", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.data_format {
                builder.set_attr_string("data_format", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(MaxPoolGradInst { op })
    }
}
impl MaxPoolGradInst {
    /// Returns the 'output' Output of this 'MaxPoolGrad' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'orig_input' Input of this 'MaxPoolGrad' operation.
    pub fn orig_input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'orig_output' Input of this 'MaxPoolGrad' operation.
    pub fn orig_output(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'grad' Input of this 'MaxPoolGrad' operation.
    pub fn grad(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<MaxPoolGradInst> for crate::Operation {
    fn from(inst: MaxPoolGradInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `MaxPoolGrad::new().build(orig_input, orig_output, grad, scope)`.
pub fn max_pool_grad<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    orig_input: O0,
    orig_output: O1,
    grad: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    MaxPoolGrad::new().build(orig_input, orig_output, grad, scope)
}

/// Builder for the `MaxPoolGradGrad` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct MaxPoolGradGrad {
    ksize: ::std::option::Option<::std::vec::Vec<i64>>,
    strides: ::std::option::Option<::std::vec::Vec<i64>>,
    padding: ::std::option::Option<::std::string::String>,
    data_format: ::std::option::Option<::std::string::String>,
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'MaxPoolGradGrad' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct MaxPoolGradGradInst {
    /// An instance of a fully built MaxPoolGradGrad Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl MaxPoolGradGrad {
    /// Creates a new `MaxPoolGradGrad`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `ksize` attribute.
    pub fn ksize<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.ksize = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `strides` attribute.
    pub fn strides<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.strides = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `padding` attribute.
    pub fn padding<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.padding = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `data_format` attribute.
    pub fn data_format<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.data_format = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `MaxPoolGradGrad` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        orig_input: O0,
        orig_output: O1,
        grad: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(orig_input.into(), orig_output.into(), grad.into(), scope)
    }
    fn build_impl(
        &self,
        orig_input: crate::Output,
        orig_output: crate::Output,
        grad: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("MaxPoolGradGrad", |nd| {
            nd.add_input(orig_input);
            nd.add_input(orig_output);
            nd.add_input(grad);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.ksize {
                nd.set_attr_int_list("ksize", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.strides {
                nd.set_attr_int_list("strides", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding {
                nd.set_attr_string("padding", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.data_format {
                nd.set_attr_string("data_format", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'MaxPoolGradGrad' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        orig_input: crate::Output,
        orig_output: crate::Output,
        grad: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<MaxPoolGradGradInst> {
        let op = scope.new_operation("MaxPoolGradGrad", |builder| {
            builder.add_input(orig_input);
            builder.add_input(orig_output);
            builder.add_input(grad);
            if let ::std::option::Option::Some(value) = &self.ksize {
                builder.set_attr_int_list("ksize", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.strides {
                builder.set_attr_int_list("strides", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding {
                builder.set_attr_string("padding", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.data_format {
                builder.set_attr_string("data_format", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(MaxPoolGradGradInst { op })
    }
}
impl MaxPoolGradGradInst {
    /// Returns the 'output' Output of this 'MaxPoolGradGrad' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'orig_input' Input of this 'MaxPoolGradGrad' operation.
    pub fn orig_input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'orig_output' Input of this 'MaxPoolGradGrad' operation.
    pub fn orig_output(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'grad' Input of this 'MaxPoolGradGrad' operation.
    pub fn grad(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<MaxPoolGradGradInst> for crate::Operation {
    fn from(inst: MaxPoolGradGradInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `MaxPoolGradGrad::new().build(orig_input, orig_output, grad, scope)`.
pub fn max_pool_grad_grad<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    orig_input: O0,
    orig_output: O1,
    grad: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    MaxPoolGradGrad::new().build(orig_input, orig_output, grad, scope)
}

/// Builder for the `MaxPoolGradGradV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct MaxPoolGradGradV2 {
    padding: ::std::option::Option<::std::string::String>,
    data_format: ::std::option::Option<::std::string::String>,
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'MaxPoolGradGradV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct MaxPoolGradGradV2Inst {
    /// An instance of a fully built MaxPoolGradGradV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl MaxPoolGradGradV2 {
    /// Creates a new `MaxPoolGradGradV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `padding` attribute.
    pub fn padding<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.padding = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `data_format` attribute.
    pub fn data_format<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.data_format = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `MaxPoolGradGradV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
    >(
        &self,
        orig_input: O0,
        orig_output: O1,
        grad: O2,
        ksize: O3,
        strides: O4,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            orig_input.into(),
            orig_output.into(),
            grad.into(),
            ksize.into(),
            strides.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        orig_input: crate::Output,
        orig_output: crate::Output,
        grad: crate::Output,
        ksize: crate::Output,
        strides: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("MaxPoolGradGradV2", |nd| {
            nd.add_input(orig_input);
            nd.add_input(orig_output);
            nd.add_input(grad);
            nd.add_input(ksize);
            nd.add_input(strides);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.padding {
                nd.set_attr_string("padding", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.data_format {
                nd.set_attr_string("data_format", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'MaxPoolGradGradV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        orig_input: crate::Output,
        orig_output: crate::Output,
        grad: crate::Output,
        ksize: crate::Output,
        strides: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<MaxPoolGradGradV2Inst> {
        let op = scope.new_operation("MaxPoolGradGradV2", |builder| {
            builder.add_input(orig_input);
            builder.add_input(orig_output);
            builder.add_input(grad);
            builder.add_input(ksize);
            builder.add_input(strides);
            if let ::std::option::Option::Some(value) = &self.padding {
                builder.set_attr_string("padding", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.data_format {
                builder.set_attr_string("data_format", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(MaxPoolGradGradV2Inst { op })
    }
}
impl MaxPoolGradGradV2Inst {
    /// Returns the 'output' Output of this 'MaxPoolGradGradV2' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'orig_input' Input of this 'MaxPoolGradGradV2' operation.
    pub fn orig_input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'orig_output' Input of this 'MaxPoolGradGradV2' operation.
    pub fn orig_output(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'grad' Input of this 'MaxPoolGradGradV2' operation.
    pub fn grad(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'ksize' Input of this 'MaxPoolGradGradV2' operation.
    pub fn ksize(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'strides' Input of this 'MaxPoolGradGradV2' operation.
    pub fn strides(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
}
impl From<MaxPoolGradGradV2Inst> for crate::Operation {
    fn from(inst: MaxPoolGradGradV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `MaxPoolGradGradV2::new().build(orig_input, orig_output, grad, ksize, strides, scope)`.
pub fn max_pool_grad_grad_v2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
>(
    orig_input: O0,
    orig_output: O1,
    grad: O2,
    ksize: O3,
    strides: O4,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    MaxPoolGradGradV2::new().build(orig_input, orig_output, grad, ksize, strides, scope)
}

/// Builder for the `MaxPoolGradGradWithArgmax` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct MaxPoolGradGradWithArgmax {
    ksize: ::std::option::Option<::std::vec::Vec<i64>>,
    strides: ::std::option::Option<::std::vec::Vec<i64>>,
    padding: ::std::option::Option<::std::string::String>,
    include_batch_in_index: ::std::option::Option<bool>,
    Targmax: ::std::option::Option<crate::DataType>,
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'MaxPoolGradGradWithArgmax' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct MaxPoolGradGradWithArgmaxInst {
    /// An instance of a fully built MaxPoolGradGradWithArgmax Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl MaxPoolGradGradWithArgmax {
    /// Creates a new `MaxPoolGradGradWithArgmax`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `ksize` attribute.
    pub fn ksize<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.ksize = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `strides` attribute.
    pub fn strides<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.strides = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `padding` attribute.
    pub fn padding<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.padding = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `include_batch_in_index` attribute.
    pub fn include_batch_in_index<ArgType: ::std::convert::Into<bool>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.include_batch_in_index = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Targmax` attribute.
    pub fn Targmax<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Targmax = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `MaxPoolGradGradWithArgmax` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        grad: O1,
        argmax: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), grad.into(), argmax.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        grad: crate::Output,
        argmax: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("MaxPoolGradGradWithArgmax", |nd| {
            nd.add_input(input);
            nd.add_input(grad);
            nd.add_input(argmax);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.ksize {
                nd.set_attr_int_list("ksize", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.strides {
                nd.set_attr_int_list("strides", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding {
                nd.set_attr_string("padding", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.include_batch_in_index {
                nd.set_attr_bool("include_batch_in_index", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Targmax {
                nd.set_attr_type("Targmax", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'MaxPoolGradGradWithArgmax' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        grad: crate::Output,
        argmax: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<MaxPoolGradGradWithArgmaxInst> {
        let op = scope.new_operation("MaxPoolGradGradWithArgmax", |builder| {
            builder.add_input(input);
            builder.add_input(grad);
            builder.add_input(argmax);
            if let ::std::option::Option::Some(value) = &self.ksize {
                builder.set_attr_int_list("ksize", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.strides {
                builder.set_attr_int_list("strides", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding {
                builder.set_attr_string("padding", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.include_batch_in_index {
                builder.set_attr_bool("include_batch_in_index", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Targmax {
                builder.set_attr_type("Targmax", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(MaxPoolGradGradWithArgmaxInst { op })
    }
}
impl MaxPoolGradGradWithArgmaxInst {
    /// Returns the 'output' Output of this 'MaxPoolGradGradWithArgmax' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'MaxPoolGradGradWithArgmax' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'grad' Input of this 'MaxPoolGradGradWithArgmax' operation.
    pub fn grad(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'argmax' Input of this 'MaxPoolGradGradWithArgmax' operation.
    pub fn argmax(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<MaxPoolGradGradWithArgmaxInst> for crate::Operation {
    fn from(inst: MaxPoolGradGradWithArgmaxInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `MaxPoolGradGradWithArgmax::new().build(input, grad, argmax, scope)`.
pub fn max_pool_grad_grad_with_argmax<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    input: O0,
    grad: O1,
    argmax: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    MaxPoolGradGradWithArgmax::new().build(input, grad, argmax, scope)
}

/// Builder for the `MaxPoolGradV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct MaxPoolGradV2 {
    padding: ::std::option::Option<::std::string::String>,
    data_format: ::std::option::Option<::std::string::String>,
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'MaxPoolGradV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct MaxPoolGradV2Inst {
    /// An instance of a fully built MaxPoolGradV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl MaxPoolGradV2 {
    /// Creates a new `MaxPoolGradV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `padding` attribute.
    pub fn padding<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.padding = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `data_format` attribute.
    pub fn data_format<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.data_format = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `MaxPoolGradV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
    >(
        &self,
        orig_input: O0,
        orig_output: O1,
        grad: O2,
        ksize: O3,
        strides: O4,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            orig_input.into(),
            orig_output.into(),
            grad.into(),
            ksize.into(),
            strides.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        orig_input: crate::Output,
        orig_output: crate::Output,
        grad: crate::Output,
        ksize: crate::Output,
        strides: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("MaxPoolGradV2", |nd| {
            nd.add_input(orig_input);
            nd.add_input(orig_output);
            nd.add_input(grad);
            nd.add_input(ksize);
            nd.add_input(strides);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.padding {
                nd.set_attr_string("padding", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.data_format {
                nd.set_attr_string("data_format", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'MaxPoolGradV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        orig_input: crate::Output,
        orig_output: crate::Output,
        grad: crate::Output,
        ksize: crate::Output,
        strides: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<MaxPoolGradV2Inst> {
        let op = scope.new_operation("MaxPoolGradV2", |builder| {
            builder.add_input(orig_input);
            builder.add_input(orig_output);
            builder.add_input(grad);
            builder.add_input(ksize);
            builder.add_input(strides);
            if let ::std::option::Option::Some(value) = &self.padding {
                builder.set_attr_string("padding", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.data_format {
                builder.set_attr_string("data_format", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(MaxPoolGradV2Inst { op })
    }
}
impl MaxPoolGradV2Inst {
    /// Returns the 'output' Output of this 'MaxPoolGradV2' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'orig_input' Input of this 'MaxPoolGradV2' operation.
    pub fn orig_input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'orig_output' Input of this 'MaxPoolGradV2' operation.
    pub fn orig_output(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'grad' Input of this 'MaxPoolGradV2' operation.
    pub fn grad(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'ksize' Input of this 'MaxPoolGradV2' operation.
    pub fn ksize(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'strides' Input of this 'MaxPoolGradV2' operation.
    pub fn strides(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
}
impl From<MaxPoolGradV2Inst> for crate::Operation {
    fn from(inst: MaxPoolGradV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `MaxPoolGradV2::new().build(orig_input, orig_output, grad, ksize, strides, scope)`.
pub fn max_pool_grad_v2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
>(
    orig_input: O0,
    orig_output: O1,
    grad: O2,
    ksize: O3,
    strides: O4,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    MaxPoolGradV2::new().build(orig_input, orig_output, grad, ksize, strides, scope)
}

/// Builder for the `MaxPoolGradWithArgmax` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct MaxPoolGradWithArgmax {
    ksize: ::std::option::Option<::std::vec::Vec<i64>>,
    strides: ::std::option::Option<::std::vec::Vec<i64>>,
    padding: ::std::option::Option<::std::string::String>,
    include_batch_in_index: ::std::option::Option<bool>,
    Targmax: ::std::option::Option<crate::DataType>,
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'MaxPoolGradWithArgmax' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct MaxPoolGradWithArgmaxInst {
    /// An instance of a fully built MaxPoolGradWithArgmax Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl MaxPoolGradWithArgmax {
    /// Creates a new `MaxPoolGradWithArgmax`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `ksize` attribute.
    pub fn ksize<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.ksize = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `strides` attribute.
    pub fn strides<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.strides = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `padding` attribute.
    pub fn padding<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.padding = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `include_batch_in_index` attribute.
    pub fn include_batch_in_index<ArgType: ::std::convert::Into<bool>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.include_batch_in_index = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Targmax` attribute.
    pub fn Targmax<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Targmax = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `MaxPoolGradWithArgmax` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        grad: O1,
        argmax: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), grad.into(), argmax.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        grad: crate::Output,
        argmax: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("MaxPoolGradWithArgmax", |nd| {
            nd.add_input(input);
            nd.add_input(grad);
            nd.add_input(argmax);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.ksize {
                nd.set_attr_int_list("ksize", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.strides {
                nd.set_attr_int_list("strides", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding {
                nd.set_attr_string("padding", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.include_batch_in_index {
                nd.set_attr_bool("include_batch_in_index", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Targmax {
                nd.set_attr_type("Targmax", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'MaxPoolGradWithArgmax' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        grad: crate::Output,
        argmax: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<MaxPoolGradWithArgmaxInst> {
        let op = scope.new_operation("MaxPoolGradWithArgmax", |builder| {
            builder.add_input(input);
            builder.add_input(grad);
            builder.add_input(argmax);
            if let ::std::option::Option::Some(value) = &self.ksize {
                builder.set_attr_int_list("ksize", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.strides {
                builder.set_attr_int_list("strides", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding {
                builder.set_attr_string("padding", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.include_batch_in_index {
                builder.set_attr_bool("include_batch_in_index", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Targmax {
                builder.set_attr_type("Targmax", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(MaxPoolGradWithArgmaxInst { op })
    }
}
impl MaxPoolGradWithArgmaxInst {
    /// Returns the 'output' Output of this 'MaxPoolGradWithArgmax' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'MaxPoolGradWithArgmax' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'grad' Input of this 'MaxPoolGradWithArgmax' operation.
    pub fn grad(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'argmax' Input of this 'MaxPoolGradWithArgmax' operation.
    pub fn argmax(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<MaxPoolGradWithArgmaxInst> for crate::Operation {
    fn from(inst: MaxPoolGradWithArgmaxInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `MaxPoolGradWithArgmax::new().build(input, grad, argmax, scope)`.
pub fn max_pool_grad_with_argmax<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    input: O0,
    grad: O1,
    argmax: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    MaxPoolGradWithArgmax::new().build(input, grad, argmax, scope)
}

/// Builder for the `MaxPoolV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct MaxPoolV2 {
    T: ::std::option::Option<crate::DataType>,
    padding: ::std::option::Option<::std::string::String>,
    data_format: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'MaxPoolV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct MaxPoolV2Inst {
    /// An instance of a fully built MaxPoolV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl MaxPoolV2 {
    /// Creates a new `MaxPoolV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `padding` attribute.
    pub fn padding<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.padding = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `data_format` attribute.
    pub fn data_format<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.data_format = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `MaxPoolV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        ksize: O1,
        strides: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), ksize.into(), strides.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        ksize: crate::Output,
        strides: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("MaxPoolV2", |nd| {
            nd.add_input(input);
            nd.add_input(ksize);
            nd.add_input(strides);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding {
                nd.set_attr_string("padding", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.data_format {
                nd.set_attr_string("data_format", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'MaxPoolV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        ksize: crate::Output,
        strides: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<MaxPoolV2Inst> {
        let op = scope.new_operation("MaxPoolV2", |builder| {
            builder.add_input(input);
            builder.add_input(ksize);
            builder.add_input(strides);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding {
                builder.set_attr_string("padding", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.data_format {
                builder.set_attr_string("data_format", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(MaxPoolV2Inst { op })
    }
}
impl MaxPoolV2Inst {
    /// Returns the 'output' Output of this 'MaxPoolV2' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'MaxPoolV2' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'ksize' Input of this 'MaxPoolV2' operation.
    pub fn ksize(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'strides' Input of this 'MaxPoolV2' operation.
    pub fn strides(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<MaxPoolV2Inst> for crate::Operation {
    fn from(inst: MaxPoolV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `MaxPoolV2::new().build(input, ksize, strides, scope)`.
pub fn max_pool_v2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    input: O0,
    ksize: O1,
    strides: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    MaxPoolV2::new().build(input, ksize, strides, scope)
}

/// Builder for the `MaxPoolWithArgmax` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct MaxPoolWithArgmax {
    ksize: ::std::option::Option<::std::vec::Vec<i64>>,
    strides: ::std::option::Option<::std::vec::Vec<i64>>,
    Targmax: ::std::option::Option<crate::DataType>,
    padding: ::std::option::Option<::std::string::String>,
    include_batch_in_index: ::std::option::Option<bool>,
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'MaxPoolWithArgmax' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct MaxPoolWithArgmaxInst {
    /// An instance of a fully built MaxPoolWithArgmax Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl MaxPoolWithArgmax {
    /// Creates a new `MaxPoolWithArgmax`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `ksize` attribute.
    pub fn ksize<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.ksize = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `strides` attribute.
    pub fn strides<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.strides = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Targmax` attribute.
    pub fn Targmax<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Targmax = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `padding` attribute.
    pub fn padding<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.padding = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `include_batch_in_index` attribute.
    pub fn include_batch_in_index<ArgType: ::std::convert::Into<bool>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.include_batch_in_index = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `MaxPoolWithArgmax` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("MaxPoolWithArgmax", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.ksize {
                nd.set_attr_int_list("ksize", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.strides {
                nd.set_attr_int_list("strides", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Targmax {
                nd.set_attr_type("Targmax", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding {
                nd.set_attr_string("padding", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.include_batch_in_index {
                nd.set_attr_bool("include_batch_in_index", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'MaxPoolWithArgmax' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<MaxPoolWithArgmaxInst> {
        let op = scope.new_operation("MaxPoolWithArgmax", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.ksize {
                builder.set_attr_int_list("ksize", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.strides {
                builder.set_attr_int_list("strides", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Targmax {
                builder.set_attr_type("Targmax", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding {
                builder.set_attr_string("padding", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.include_batch_in_index {
                builder.set_attr_bool("include_batch_in_index", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(MaxPoolWithArgmaxInst { op })
    }
}
impl MaxPoolWithArgmaxInst {
    /// Returns the 'output' Output of this 'MaxPoolWithArgmax' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'argmax' Output of this 'MaxPoolWithArgmax' operation.
    pub fn argmax(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'input' Input of this 'MaxPoolWithArgmax' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<MaxPoolWithArgmaxInst> for crate::Operation {
    fn from(inst: MaxPoolWithArgmaxInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `MaxPoolWithArgmax::new().build(input, scope)`.
pub fn max_pool_with_argmax<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    MaxPoolWithArgmax::new().build(input, scope)
}

/// Builder for the `Maximum` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Maximum {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Maximum' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct MaximumInst {
    /// An instance of a fully built Maximum Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Maximum {
    /// Creates a new `Maximum`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Maximum` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        x: O0,
        y: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), y.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        y: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Maximum", |nd| {
            nd.add_input(x);
            nd.add_input(y);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Maximum' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        y: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<MaximumInst> {
        let op = scope.new_operation("Maximum", |builder| {
            builder.add_input(x);
            builder.add_input(y);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(MaximumInst { op })
    }
}
impl MaximumInst {
    /// Returns the 'z' Output of this 'Maximum' operation.
    pub fn z(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'Maximum' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'y' Input of this 'Maximum' operation.
    pub fn y(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<MaximumInst> for crate::Operation {
    fn from(inst: MaximumInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Maximum::new().build(x, y, scope)`.
pub fn maximum<O0: ::std::convert::Into<crate::Output>, O1: ::std::convert::Into<crate::Output>>(
    x: O0,
    y: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Maximum::new().build(x, y, scope)
}

/// Builder for the `Mean` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Mean {
    keep_dims: ::std::option::Option<bool>,
    T: ::std::option::Option<crate::DataType>,
    Tidx: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Mean' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct MeanInst {
    /// An instance of a fully built Mean Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Mean {
    /// Creates a new `Mean`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `keep_dims` attribute.
    pub fn keep_dims<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.keep_dims = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tidx` attribute.
    pub fn Tidx<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Tidx = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Mean` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        reduction_indices: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), reduction_indices.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        reduction_indices: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Mean", |nd| {
            nd.add_input(input);
            nd.add_input(reduction_indices);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.keep_dims {
                nd.set_attr_bool("keep_dims", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tidx {
                nd.set_attr_type("Tidx", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Mean' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        reduction_indices: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<MeanInst> {
        let op = scope.new_operation("Mean", |builder| {
            builder.add_input(input);
            builder.add_input(reduction_indices);
            if let ::std::option::Option::Some(value) = &self.keep_dims {
                builder.set_attr_bool("keep_dims", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tidx {
                builder.set_attr_type("Tidx", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(MeanInst { op })
    }
}
impl MeanInst {
    /// Returns the 'output' Output of this 'Mean' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'Mean' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'reduction_indices' Input of this 'Mean' operation.
    pub fn reduction_indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<MeanInst> for crate::Operation {
    fn from(inst: MeanInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Mean::new().build(input, reduction_indices, scope)`.
pub fn mean<O0: ::std::convert::Into<crate::Output>, O1: ::std::convert::Into<crate::Output>>(
    input: O0,
    reduction_indices: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Mean::new().build(input, reduction_indices, scope)
}

/// Builder for the `Merge` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Merge {
    T: ::std::option::Option<crate::DataType>,
    N: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Merge' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct MergeInst {
    /// An instance of a fully built Merge Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Merge {
    /// Creates a new `Merge`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `N` attribute.
    pub fn N<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.N = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Merge` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        inputs: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(inputs.into(), scope)
    }
    fn build_impl(
        &self,
        inputs: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Merge", |nd| {
            nd.add_input(inputs);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.N {
                nd.set_attr_int("N", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Merge' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        inputs: Vec<crate::Output>,
        scope: &mut crate::Scope,
    ) -> crate::Result<MergeInst> {
        let op = scope.new_operation("Merge", |builder| {
            builder.add_input_list(&inputs);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            builder.set_attr_int("N", inputs.clone().len() as i64)?;
            ::std::result::Result::Ok(())
        })?;
        Ok(MergeInst { op })
    }
}
impl MergeInst {
    /// Returns the 'output' Output of this 'Merge' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'value_index' Output of this 'Merge' operation.
    pub fn value_index(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns a Vector of inputs for 'inputs' Input of this Merge operation.
    pub fn inputs(&self) -> crate::Result<Vec<crate::Input>> {
        let mut Inputs = vec![];
        for i in 0..self.op.get_attr_int("N")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
}
impl From<MergeInst> for crate::Operation {
    fn from(inst: MergeInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Merge::new().build(inputs, scope)`.
pub fn merge<O0: ::std::convert::Into<crate::Output>>(
    inputs: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Merge::new().build(inputs, scope)
}

/// Builder for the `MergeDedupData` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct MergeDedupData {
    tuple_mask: ::std::option::Option<::std::string::String>,
    integer_type: ::std::option::Option<crate::DataType>,
    float_type: ::std::option::Option<crate::DataType>,
    config: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'MergeDedupData' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct MergeDedupDataInst {
    /// An instance of a fully built MergeDedupData Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl MergeDedupData {
    /// Creates a new `MergeDedupData`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `tuple_mask` attribute.
    pub fn tuple_mask<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.tuple_mask = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `integer_type` attribute.
    pub fn integer_type<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.integer_type = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `float_type` attribute.
    pub fn float_type<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.float_type = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `config` attribute.
    pub fn config<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.config = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `MergeDedupData` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        integer_tensor: O0,
        float_tensor: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(integer_tensor.into(), float_tensor.into(), scope)
    }
    fn build_impl(
        &self,
        integer_tensor: crate::Output,
        float_tensor: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("MergeDedupData", |nd| {
            nd.add_input(integer_tensor);
            nd.add_input(float_tensor);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.tuple_mask {
                nd.set_attr_string("tuple_mask", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.integer_type {
                nd.set_attr_type("integer_type", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.float_type {
                nd.set_attr_type("float_type", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.config {
                nd.set_attr_string("config", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'MergeDedupData' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        integer_tensor: crate::Output,
        float_tensor: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<MergeDedupDataInst> {
        let op = scope.new_operation("MergeDedupData", |builder| {
            builder.add_input(integer_tensor);
            builder.add_input(float_tensor);
            if let ::std::option::Option::Some(value) = &self.tuple_mask {
                builder.set_attr_string("tuple_mask", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.integer_type {
                builder.set_attr_type("integer_type", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.float_type {
                builder.set_attr_type("float_type", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.config {
                builder.set_attr_string("config", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(MergeDedupDataInst { op })
    }
}
impl MergeDedupDataInst {
    /// Returns the 'output' Output of this 'MergeDedupData' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'integer_tensor' Input of this 'MergeDedupData' operation.
    pub fn integer_tensor(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'float_tensor' Input of this 'MergeDedupData' operation.
    pub fn float_tensor(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<MergeDedupDataInst> for crate::Operation {
    fn from(inst: MergeDedupDataInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `MergeDedupData::new().build(integer_tensor, float_tensor, scope)`.
pub fn merge_dedup_data<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    integer_tensor: O0,
    float_tensor: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    MergeDedupData::new().build(integer_tensor, float_tensor, scope)
}

/// Builder for the `MergeSummary` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct MergeSummary {
    N: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'MergeSummary' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct MergeSummaryInst {
    /// An instance of a fully built MergeSummary Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl MergeSummary {
    /// Creates a new `MergeSummary`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `N` attribute.
    pub fn N<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.N = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `MergeSummary` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        inputs: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(inputs.into(), scope)
    }
    fn build_impl(
        &self,
        inputs: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("MergeSummary", |nd| {
            nd.add_input(inputs);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.N {
                nd.set_attr_int("N", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'MergeSummary' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        inputs: Vec<crate::Output>,
        scope: &mut crate::Scope,
    ) -> crate::Result<MergeSummaryInst> {
        let op = scope.new_operation("MergeSummary", |builder| {
            builder.add_input_list(&inputs);
            builder.set_attr_int("N", inputs.clone().len() as i64)?;
            ::std::result::Result::Ok(())
        })?;
        Ok(MergeSummaryInst { op })
    }
}
impl MergeSummaryInst {
    /// Returns the 'summary' Output of this 'MergeSummary' operation.
    pub fn summary(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns a Vector of inputs for 'inputs' Input of this MergeSummary operation.
    pub fn inputs(&self) -> crate::Result<Vec<crate::Input>> {
        let mut Inputs = vec![];
        for i in 0..self.op.get_attr_int("N")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
}
impl From<MergeSummaryInst> for crate::Operation {
    fn from(inst: MergeSummaryInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `MergeSummary::new().build(inputs, scope)`.
pub fn merge_summary<O0: ::std::convert::Into<crate::Output>>(
    inputs: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    MergeSummary::new().build(inputs, scope)
}

/// Builder for the `MergeV2Checkpoints` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct MergeV2Checkpoints {
    delete_old_dirs: ::std::option::Option<bool>,
    allow_missing_files: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'MergeV2Checkpoints' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct MergeV2CheckpointsInst {
    /// An instance of a fully built MergeV2Checkpoints Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl MergeV2Checkpoints {
    /// Creates a new `MergeV2Checkpoints`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `delete_old_dirs` attribute.
    pub fn delete_old_dirs<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.delete_old_dirs = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `allow_missing_files` attribute.
    pub fn allow_missing_files<ArgType: ::std::convert::Into<bool>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.allow_missing_files = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `MergeV2Checkpoints` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        checkpoint_prefixes: O0,
        destination_prefix: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(checkpoint_prefixes.into(), destination_prefix.into(), scope)
    }
    fn build_impl(
        &self,
        checkpoint_prefixes: crate::Output,
        destination_prefix: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("MergeV2Checkpoints", |nd| {
            nd.add_input(checkpoint_prefixes);
            nd.add_input(destination_prefix);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.delete_old_dirs {
                nd.set_attr_bool("delete_old_dirs", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.allow_missing_files {
                nd.set_attr_bool("allow_missing_files", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'MergeV2Checkpoints' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        checkpoint_prefixes: crate::Output,
        destination_prefix: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<MergeV2CheckpointsInst> {
        let op = scope.new_operation("MergeV2Checkpoints", |builder| {
            builder.add_input(checkpoint_prefixes);
            builder.add_input(destination_prefix);
            if let ::std::option::Option::Some(value) = &self.delete_old_dirs {
                builder.set_attr_bool("delete_old_dirs", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.allow_missing_files {
                builder.set_attr_bool("allow_missing_files", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(MergeV2CheckpointsInst { op })
    }
}
impl MergeV2CheckpointsInst {
    /// Returns the 'checkpoint_prefixes' Input of this 'MergeV2Checkpoints' operation.
    pub fn checkpoint_prefixes(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'destination_prefix' Input of this 'MergeV2Checkpoints' operation.
    pub fn destination_prefix(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<MergeV2CheckpointsInst> for crate::Operation {
    fn from(inst: MergeV2CheckpointsInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `MergeV2Checkpoints::new().build(checkpoint_prefixes, destination_prefix, scope)`.
pub fn merge_v2_checkpoints<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    checkpoint_prefixes: O0,
    destination_prefix: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    MergeV2Checkpoints::new().build(checkpoint_prefixes, destination_prefix, scope)
}

/// Builder for the `Mfcc` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Mfcc {
    upper_frequency_limit: ::std::option::Option<f32>,
    lower_frequency_limit: ::std::option::Option<f32>,
    filterbank_channel_count: ::std::option::Option<i64>,
    dct_coefficient_count: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Mfcc' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct MfccInst {
    /// An instance of a fully built Mfcc Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Mfcc {
    /// Creates a new `Mfcc`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `upper_frequency_limit` attribute.
    pub fn upper_frequency_limit<ArgType: ::std::convert::Into<f32>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.upper_frequency_limit = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `lower_frequency_limit` attribute.
    pub fn lower_frequency_limit<ArgType: ::std::convert::Into<f32>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.lower_frequency_limit = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `filterbank_channel_count` attribute.
    pub fn filterbank_channel_count<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.filterbank_channel_count = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `dct_coefficient_count` attribute.
    pub fn dct_coefficient_count<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.dct_coefficient_count = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Mfcc` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        spectrogram: O0,
        sample_rate: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(spectrogram.into(), sample_rate.into(), scope)
    }
    fn build_impl(
        &self,
        spectrogram: crate::Output,
        sample_rate: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Mfcc", |nd| {
            nd.add_input(spectrogram);
            nd.add_input(sample_rate);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.upper_frequency_limit {
                nd.set_attr_float("upper_frequency_limit", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.lower_frequency_limit {
                nd.set_attr_float("lower_frequency_limit", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.filterbank_channel_count {
                nd.set_attr_int("filterbank_channel_count", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dct_coefficient_count {
                nd.set_attr_int("dct_coefficient_count", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Mfcc' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        spectrogram: crate::Output,
        sample_rate: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<MfccInst> {
        let op = scope.new_operation("Mfcc", |builder| {
            builder.add_input(spectrogram);
            builder.add_input(sample_rate);
            if let ::std::option::Option::Some(value) = &self.upper_frequency_limit {
                builder.set_attr_float("upper_frequency_limit", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.lower_frequency_limit {
                builder.set_attr_float("lower_frequency_limit", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.filterbank_channel_count {
                builder.set_attr_int("filterbank_channel_count", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dct_coefficient_count {
                builder.set_attr_int("dct_coefficient_count", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(MfccInst { op })
    }
}
impl MfccInst {
    /// Returns the 'output' Output of this 'Mfcc' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'spectrogram' Input of this 'Mfcc' operation.
    pub fn spectrogram(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'sample_rate' Input of this 'Mfcc' operation.
    pub fn sample_rate(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<MfccInst> for crate::Operation {
    fn from(inst: MfccInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Mfcc::new().build(spectrogram, sample_rate, scope)`.
pub fn mfcc<O0: ::std::convert::Into<crate::Output>, O1: ::std::convert::Into<crate::Output>>(
    spectrogram: O0,
    sample_rate: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Mfcc::new().build(spectrogram, sample_rate, scope)
}

/// Builder for the `Min` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Min {
    keep_dims: ::std::option::Option<bool>,
    T: ::std::option::Option<crate::DataType>,
    Tidx: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Min' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct MinInst {
    /// An instance of a fully built Min Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Min {
    /// Creates a new `Min`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `keep_dims` attribute.
    pub fn keep_dims<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.keep_dims = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tidx` attribute.
    pub fn Tidx<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Tidx = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Min` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        reduction_indices: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), reduction_indices.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        reduction_indices: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Min", |nd| {
            nd.add_input(input);
            nd.add_input(reduction_indices);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.keep_dims {
                nd.set_attr_bool("keep_dims", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tidx {
                nd.set_attr_type("Tidx", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Min' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        reduction_indices: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<MinInst> {
        let op = scope.new_operation("Min", |builder| {
            builder.add_input(input);
            builder.add_input(reduction_indices);
            if let ::std::option::Option::Some(value) = &self.keep_dims {
                builder.set_attr_bool("keep_dims", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tidx {
                builder.set_attr_type("Tidx", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(MinInst { op })
    }
}
impl MinInst {
    /// Returns the 'output' Output of this 'Min' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'Min' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'reduction_indices' Input of this 'Min' operation.
    pub fn reduction_indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<MinInst> for crate::Operation {
    fn from(inst: MinInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Min::new().build(input, reduction_indices, scope)`.
pub fn min<O0: ::std::convert::Into<crate::Output>, O1: ::std::convert::Into<crate::Output>>(
    input: O0,
    reduction_indices: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Min::new().build(input, reduction_indices, scope)
}

/// Builder for the `Minimum` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Minimum {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Minimum' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct MinimumInst {
    /// An instance of a fully built Minimum Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Minimum {
    /// Creates a new `Minimum`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Minimum` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        x: O0,
        y: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), y.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        y: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Minimum", |nd| {
            nd.add_input(x);
            nd.add_input(y);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Minimum' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        y: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<MinimumInst> {
        let op = scope.new_operation("Minimum", |builder| {
            builder.add_input(x);
            builder.add_input(y);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(MinimumInst { op })
    }
}
impl MinimumInst {
    /// Returns the 'z' Output of this 'Minimum' operation.
    pub fn z(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'Minimum' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'y' Input of this 'Minimum' operation.
    pub fn y(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<MinimumInst> for crate::Operation {
    fn from(inst: MinimumInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Minimum::new().build(x, y, scope)`.
pub fn minimum<O0: ::std::convert::Into<crate::Output>, O1: ::std::convert::Into<crate::Output>>(
    x: O0,
    y: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Minimum::new().build(x, y, scope)
}

/// Builder for the `MirrorPad` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct MirrorPad {
    T: ::std::option::Option<crate::DataType>,
    Tpaddings: ::std::option::Option<crate::DataType>,
    mode: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'MirrorPad' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct MirrorPadInst {
    /// An instance of a fully built MirrorPad Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl MirrorPad {
    /// Creates a new `MirrorPad`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tpaddings` attribute.
    pub fn Tpaddings<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tpaddings = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `mode` attribute.
    pub fn mode<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.mode = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `MirrorPad` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        paddings: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), paddings.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        paddings: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("MirrorPad", |nd| {
            nd.add_input(input);
            nd.add_input(paddings);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tpaddings {
                nd.set_attr_type("Tpaddings", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.mode {
                nd.set_attr_string("mode", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'MirrorPad' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        paddings: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<MirrorPadInst> {
        let op = scope.new_operation("MirrorPad", |builder| {
            builder.add_input(input);
            builder.add_input(paddings);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tpaddings {
                builder.set_attr_type("Tpaddings", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.mode {
                builder.set_attr_string("mode", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(MirrorPadInst { op })
    }
}
impl MirrorPadInst {
    /// Returns the 'output' Output of this 'MirrorPad' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'MirrorPad' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'paddings' Input of this 'MirrorPad' operation.
    pub fn paddings(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<MirrorPadInst> for crate::Operation {
    fn from(inst: MirrorPadInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `MirrorPad::new().build(input, paddings, scope)`.
pub fn mirror_pad<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    input: O0,
    paddings: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    MirrorPad::new().build(input, paddings, scope)
}

/// Builder for the `MirrorPadGrad` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct MirrorPadGrad {
    T: ::std::option::Option<crate::DataType>,
    Tpaddings: ::std::option::Option<crate::DataType>,
    mode: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'MirrorPadGrad' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct MirrorPadGradInst {
    /// An instance of a fully built MirrorPadGrad Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl MirrorPadGrad {
    /// Creates a new `MirrorPadGrad`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tpaddings` attribute.
    pub fn Tpaddings<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tpaddings = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `mode` attribute.
    pub fn mode<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.mode = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `MirrorPadGrad` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        paddings: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), paddings.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        paddings: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("MirrorPadGrad", |nd| {
            nd.add_input(input);
            nd.add_input(paddings);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tpaddings {
                nd.set_attr_type("Tpaddings", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.mode {
                nd.set_attr_string("mode", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'MirrorPadGrad' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        paddings: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<MirrorPadGradInst> {
        let op = scope.new_operation("MirrorPadGrad", |builder| {
            builder.add_input(input);
            builder.add_input(paddings);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tpaddings {
                builder.set_attr_type("Tpaddings", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.mode {
                builder.set_attr_string("mode", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(MirrorPadGradInst { op })
    }
}
impl MirrorPadGradInst {
    /// Returns the 'output' Output of this 'MirrorPadGrad' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'MirrorPadGrad' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'paddings' Input of this 'MirrorPadGrad' operation.
    pub fn paddings(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<MirrorPadGradInst> for crate::Operation {
    fn from(inst: MirrorPadGradInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `MirrorPadGrad::new().build(input, paddings, scope)`.
pub fn mirror_pad_grad<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    input: O0,
    paddings: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    MirrorPadGrad::new().build(input, paddings, scope)
}

/// Builder for the `MlirPassthroughOp` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct MlirPassthroughOp {
    mlir_module: ::std::option::Option<::std::string::String>,
    Tinputs: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    Toutputs: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'MlirPassthroughOp' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct MlirPassthroughOpInst {
    /// An instance of a fully built MlirPassthroughOp Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl MlirPassthroughOp {
    /// Creates a new `MlirPassthroughOp`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `mlir_module` attribute.
    pub fn mlir_module<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.mlir_module = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tinputs` attribute.
    pub fn Tinputs<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tinputs = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Toutputs` attribute.
    pub fn Toutputs<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Toutputs = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `MlirPassthroughOp` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        inputs: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(inputs.into(), scope)
    }
    fn build_impl(
        &self,
        inputs: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("MlirPassthroughOp", |nd| {
            nd.add_input(inputs);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.mlir_module {
                nd.set_attr_string("mlir_module", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tinputs {
                nd.set_attr_type_list("Tinputs", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Toutputs {
                nd.set_attr_type_list("Toutputs", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'MlirPassthroughOp' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        inputs: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<MlirPassthroughOpInst> {
        let op = scope.new_operation("MlirPassthroughOp", |builder| {
            builder.add_input(inputs);
            if let ::std::option::Option::Some(value) = &self.mlir_module {
                builder.set_attr_string("mlir_module", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tinputs {
                builder.set_attr_type_list("Tinputs", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Toutputs {
                builder.set_attr_type_list("Toutputs", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(MlirPassthroughOpInst { op })
    }
}
impl MlirPassthroughOpInst {
    /// Returns the 'outputs' Output of this 'MlirPassthroughOp' operation.
    pub fn outputs(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'inputs' Input of this 'MlirPassthroughOp' operation.
    pub fn inputs(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<MlirPassthroughOpInst> for crate::Operation {
    fn from(inst: MlirPassthroughOpInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `MlirPassthroughOp::new().build(inputs, scope)`.
pub fn mlir_passthrough_op<O0: ::std::convert::Into<crate::Output>>(
    inputs: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    MlirPassthroughOp::new().build(inputs, scope)
}

/// Builder for the `Mod` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Mod {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Mod' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ModInst {
    /// An instance of a fully built Mod Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Mod {
    /// Creates a new `Mod`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Mod` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        x: O0,
        y: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), y.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        y: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Mod", |nd| {
            nd.add_input(x);
            nd.add_input(y);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Mod' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        y: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ModInst> {
        let op = scope.new_operation("Mod", |builder| {
            builder.add_input(x);
            builder.add_input(y);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ModInst { op })
    }
}
impl ModInst {
    /// Returns the 'z' Output of this 'Mod' operation.
    pub fn z(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'Mod' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'y' Input of this 'Mod' operation.
    pub fn y(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<ModInst> for crate::Operation {
    fn from(inst: ModInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Mod::new().build(x, y, scope)`.
pub fn mod_<O0: ::std::convert::Into<crate::Output>, O1: ::std::convert::Into<crate::Output>>(
    x: O0,
    y: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Mod::new().build(x, y, scope)
}

/// Builder for the `ModelDataset` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ModelDataset {
    algorithm: ::std::option::Option<i64>,
    cpu_budget: ::std::option::Option<i64>,
    ram_budget: ::std::option::Option<i64>,
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ModelDataset' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ModelDatasetInst {
    /// An instance of a fully built ModelDataset Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ModelDataset {
    /// Creates a new `ModelDataset`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `algorithm` attribute.
    pub fn algorithm<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.algorithm = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `cpu_budget` attribute.
    pub fn cpu_budget<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.cpu_budget = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `ram_budget` attribute.
    pub fn ram_budget<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.ram_budget = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ModelDataset` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input_dataset: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input_dataset.into(), scope)
    }
    fn build_impl(
        &self,
        input_dataset: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ModelDataset", |nd| {
            nd.add_input(input_dataset);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.algorithm {
                nd.set_attr_int("algorithm", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.cpu_budget {
                nd.set_attr_int("cpu_budget", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.ram_budget {
                nd.set_attr_int("ram_budget", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ModelDataset' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_dataset: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ModelDatasetInst> {
        let op = scope.new_operation("ModelDataset", |builder| {
            builder.add_input(input_dataset);
            if let ::std::option::Option::Some(value) = &self.algorithm {
                builder.set_attr_int("algorithm", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.cpu_budget {
                builder.set_attr_int("cpu_budget", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.ram_budget {
                builder.set_attr_int("ram_budget", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ModelDatasetInst { op })
    }
}
impl ModelDatasetInst {
    /// Returns the 'handle' Output of this 'ModelDataset' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_dataset' Input of this 'ModelDataset' operation.
    pub fn input_dataset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<ModelDatasetInst> for crate::Operation {
    fn from(inst: ModelDatasetInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ModelDataset::new().build(input_dataset, scope)`.
pub fn model_dataset<O0: ::std::convert::Into<crate::Output>>(
    input_dataset: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ModelDataset::new().build(input_dataset, scope)
}

/// Builder for the `Mul` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Mul {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Mul' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct MulInst {
    /// An instance of a fully built Mul Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Mul {
    /// Creates a new `Mul`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Mul` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        x: O0,
        y: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), y.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        y: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Mul", |nd| {
            nd.add_input(x);
            nd.add_input(y);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Mul' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        y: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<MulInst> {
        let op = scope.new_operation("Mul", |builder| {
            builder.add_input(x);
            builder.add_input(y);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(MulInst { op })
    }
}
impl MulInst {
    /// Returns the 'z' Output of this 'Mul' operation.
    pub fn z(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'Mul' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'y' Input of this 'Mul' operation.
    pub fn y(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<MulInst> for crate::Operation {
    fn from(inst: MulInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Mul::new().build(x, y, scope)`.
pub fn mul<O0: ::std::convert::Into<crate::Output>, O1: ::std::convert::Into<crate::Output>>(
    x: O0,
    y: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Mul::new().build(x, y, scope)
}

/// Builder for the `MulNoNan` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct MulNoNan {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'MulNoNan' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct MulNoNanInst {
    /// An instance of a fully built MulNoNan Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl MulNoNan {
    /// Creates a new `MulNoNan`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `MulNoNan` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        x: O0,
        y: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), y.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        y: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("MulNoNan", |nd| {
            nd.add_input(x);
            nd.add_input(y);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'MulNoNan' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        y: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<MulNoNanInst> {
        let op = scope.new_operation("MulNoNan", |builder| {
            builder.add_input(x);
            builder.add_input(y);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(MulNoNanInst { op })
    }
}
impl MulNoNanInst {
    /// Returns the 'z' Output of this 'MulNoNan' operation.
    pub fn z(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'MulNoNan' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'y' Input of this 'MulNoNan' operation.
    pub fn y(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<MulNoNanInst> for crate::Operation {
    fn from(inst: MulNoNanInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `MulNoNan::new().build(x, y, scope)`.
pub fn mul_no_nan<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    x: O0,
    y: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    MulNoNan::new().build(x, y, scope)
}

/// Builder for the `MultiDeviceIterator` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct MultiDeviceIterator {
    devices: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
    shared_name: ::std::option::Option<::std::string::String>,
    container: ::std::option::Option<::std::string::String>,
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'MultiDeviceIterator' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct MultiDeviceIteratorInst {
    /// An instance of a fully built MultiDeviceIterator Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl MultiDeviceIterator {
    /// Creates a new `MultiDeviceIterator`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `devices` attribute.
    pub fn devices<ArgType: ::std::convert::Into<::std::vec::Vec<::std::string::String>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.devices = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shared_name` attribute.
    pub fn shared_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.shared_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `container` attribute.
    pub fn container<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.container = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `MultiDeviceIterator` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("MultiDeviceIterator", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.devices {
                nd.set_attr_string_list("devices", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                nd.set_attr_string("shared_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.container {
                nd.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'MultiDeviceIterator' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        scope: &mut crate::Scope,
    ) -> crate::Result<MultiDeviceIteratorInst> {
        let op = scope.new_operation("MultiDeviceIterator", |builder| {
            if let ::std::option::Option::Some(value) = &self.devices {
                builder.set_attr_string_list("devices", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                builder.set_attr_string("shared_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.container {
                builder.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(MultiDeviceIteratorInst { op })
    }
}
impl MultiDeviceIteratorInst {
    /// Returns the 'handle' Output of this 'MultiDeviceIterator' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
}
impl From<MultiDeviceIteratorInst> for crate::Operation {
    fn from(inst: MultiDeviceIteratorInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `MultiDeviceIterator::new().build(scope)`.
pub fn multi_device_iterator(scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
    MultiDeviceIterator::new().build(scope)
}

/// Builder for the `MultiDeviceIteratorFromStringHandle` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct MultiDeviceIteratorFromStringHandle {
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'MultiDeviceIteratorFromStringHandle' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct MultiDeviceIteratorFromStringHandleInst {
    /// An instance of a fully built MultiDeviceIteratorFromStringHandle Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl MultiDeviceIteratorFromStringHandle {
    /// Creates a new `MultiDeviceIteratorFromStringHandle`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `MultiDeviceIteratorFromStringHandle` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        string_handle: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(string_handle.into(), scope)
    }
    fn build_impl(
        &self,
        string_handle: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("MultiDeviceIteratorFromStringHandle", |nd| {
            nd.add_input(string_handle);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'MultiDeviceIteratorFromStringHandle' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        string_handle: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<MultiDeviceIteratorFromStringHandleInst> {
        let op = scope.new_operation("MultiDeviceIteratorFromStringHandle", |builder| {
            builder.add_input(string_handle);
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(MultiDeviceIteratorFromStringHandleInst { op })
    }
}
impl MultiDeviceIteratorFromStringHandleInst {
    /// Returns the 'multi_device_iterator' Output of this 'MultiDeviceIteratorFromStringHandle' operation.
    pub fn multi_device_iterator(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'string_handle' Input of this 'MultiDeviceIteratorFromStringHandle' operation.
    pub fn string_handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<MultiDeviceIteratorFromStringHandleInst> for crate::Operation {
    fn from(inst: MultiDeviceIteratorFromStringHandleInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `MultiDeviceIteratorFromStringHandle::new().build(string_handle, scope)`.
pub fn multi_device_iterator_from_string_handle<O0: ::std::convert::Into<crate::Output>>(
    string_handle: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    MultiDeviceIteratorFromStringHandle::new().build(string_handle, scope)
}

/// Builder for the `MultiDeviceIteratorGetNextFromShard` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct MultiDeviceIteratorGetNextFromShard {
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'MultiDeviceIteratorGetNextFromShard' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct MultiDeviceIteratorGetNextFromShardInst {
    /// An instance of a fully built MultiDeviceIteratorGetNextFromShard Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl MultiDeviceIteratorGetNextFromShard {
    /// Creates a new `MultiDeviceIteratorGetNextFromShard`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `MultiDeviceIteratorGetNextFromShard` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        multi_device_iterator: O0,
        shard_num: O1,
        incarnation_id: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            multi_device_iterator.into(),
            shard_num.into(),
            incarnation_id.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        multi_device_iterator: crate::Output,
        shard_num: crate::Output,
        incarnation_id: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("MultiDeviceIteratorGetNextFromShard", |nd| {
            nd.add_input(multi_device_iterator);
            nd.add_input(shard_num);
            nd.add_input(incarnation_id);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'MultiDeviceIteratorGetNextFromShard' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        multi_device_iterator: crate::Output,
        shard_num: crate::Output,
        incarnation_id: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<MultiDeviceIteratorGetNextFromShardInst> {
        let op = scope.new_operation("MultiDeviceIteratorGetNextFromShard", |builder| {
            builder.add_input(multi_device_iterator);
            builder.add_input(shard_num);
            builder.add_input(incarnation_id);
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(MultiDeviceIteratorGetNextFromShardInst { op })
    }
}
impl MultiDeviceIteratorGetNextFromShardInst {
    /// Returns the 'components' Output of this 'MultiDeviceIteratorGetNextFromShard' operation.
    pub fn components(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'multi_device_iterator' Input of this 'MultiDeviceIteratorGetNextFromShard' operation.
    pub fn multi_device_iterator(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'shard_num' Input of this 'MultiDeviceIteratorGetNextFromShard' operation.
    pub fn shard_num(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'incarnation_id' Input of this 'MultiDeviceIteratorGetNextFromShard' operation.
    pub fn incarnation_id(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<MultiDeviceIteratorGetNextFromShardInst> for crate::Operation {
    fn from(inst: MultiDeviceIteratorGetNextFromShardInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `MultiDeviceIteratorGetNextFromShard::new().build(multi_device_iterator, shard_num, incarnation_id, scope)`.
pub fn multi_device_iterator_get_next_from_shard<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    multi_device_iterator: O0,
    shard_num: O1,
    incarnation_id: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    MultiDeviceIteratorGetNextFromShard::new().build(
        multi_device_iterator,
        shard_num,
        incarnation_id,
        scope,
    )
}

/// Builder for the `MultiDeviceIteratorInit` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct MultiDeviceIteratorInit {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'MultiDeviceIteratorInit' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct MultiDeviceIteratorInitInst {
    /// An instance of a fully built MultiDeviceIteratorInit Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl MultiDeviceIteratorInit {
    /// Creates a new `MultiDeviceIteratorInit`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `MultiDeviceIteratorInit` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        dataset: O0,
        multi_device_iterator: O1,
        max_buffer_size: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            dataset.into(),
            multi_device_iterator.into(),
            max_buffer_size.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        dataset: crate::Output,
        multi_device_iterator: crate::Output,
        max_buffer_size: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("MultiDeviceIteratorInit", |nd| {
            nd.add_input(dataset);
            nd.add_input(multi_device_iterator);
            nd.add_input(max_buffer_size);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'MultiDeviceIteratorInit' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        dataset: crate::Output,
        multi_device_iterator: crate::Output,
        max_buffer_size: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<MultiDeviceIteratorInitInst> {
        let op = scope.new_operation("MultiDeviceIteratorInit", |builder| {
            builder.add_input(dataset);
            builder.add_input(multi_device_iterator);
            builder.add_input(max_buffer_size);
            ::std::result::Result::Ok(())
        })?;
        Ok(MultiDeviceIteratorInitInst { op })
    }
}
impl MultiDeviceIteratorInitInst {
    /// Returns the 'incarnation_id' Output of this 'MultiDeviceIteratorInit' operation.
    pub fn incarnation_id(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'dataset' Input of this 'MultiDeviceIteratorInit' operation.
    pub fn dataset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'multi_device_iterator' Input of this 'MultiDeviceIteratorInit' operation.
    pub fn multi_device_iterator(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'max_buffer_size' Input of this 'MultiDeviceIteratorInit' operation.
    pub fn max_buffer_size(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<MultiDeviceIteratorInitInst> for crate::Operation {
    fn from(inst: MultiDeviceIteratorInitInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `MultiDeviceIteratorInit::new().build(dataset, multi_device_iterator, max_buffer_size, scope)`.
pub fn multi_device_iterator_init<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    dataset: O0,
    multi_device_iterator: O1,
    max_buffer_size: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    MultiDeviceIteratorInit::new().build(dataset, multi_device_iterator, max_buffer_size, scope)
}

/// Builder for the `MultiDeviceIteratorToStringHandle` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct MultiDeviceIteratorToStringHandle {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'MultiDeviceIteratorToStringHandle' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct MultiDeviceIteratorToStringHandleInst {
    /// An instance of a fully built MultiDeviceIteratorToStringHandle Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl MultiDeviceIteratorToStringHandle {
    /// Creates a new `MultiDeviceIteratorToStringHandle`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `MultiDeviceIteratorToStringHandle` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        multi_device_iterator: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(multi_device_iterator.into(), scope)
    }
    fn build_impl(
        &self,
        multi_device_iterator: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("MultiDeviceIteratorToStringHandle", |nd| {
            nd.add_input(multi_device_iterator);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'MultiDeviceIteratorToStringHandle' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        multi_device_iterator: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<MultiDeviceIteratorToStringHandleInst> {
        let op = scope.new_operation("MultiDeviceIteratorToStringHandle", |builder| {
            builder.add_input(multi_device_iterator);
            ::std::result::Result::Ok(())
        })?;
        Ok(MultiDeviceIteratorToStringHandleInst { op })
    }
}
impl MultiDeviceIteratorToStringHandleInst {
    /// Returns the 'string_handle' Output of this 'MultiDeviceIteratorToStringHandle' operation.
    pub fn string_handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'multi_device_iterator' Input of this 'MultiDeviceIteratorToStringHandle' operation.
    pub fn multi_device_iterator(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<MultiDeviceIteratorToStringHandleInst> for crate::Operation {
    fn from(inst: MultiDeviceIteratorToStringHandleInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `MultiDeviceIteratorToStringHandle::new().build(multi_device_iterator, scope)`.
pub fn multi_device_iterator_to_string_handle<O0: ::std::convert::Into<crate::Output>>(
    multi_device_iterator: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    MultiDeviceIteratorToStringHandle::new().build(multi_device_iterator, scope)
}

/// Builder for the `Multinomial` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Multinomial {
    seed: ::std::option::Option<i64>,
    seed2: ::std::option::Option<i64>,
    T: ::std::option::Option<crate::DataType>,
    output_dtype: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Multinomial' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct MultinomialInst {
    /// An instance of a fully built Multinomial Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Multinomial {
    /// Creates a new `Multinomial`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `seed` attribute.
    pub fn seed<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.seed = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `seed2` attribute.
    pub fn seed2<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.seed2 = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_dtype` attribute.
    pub fn output_dtype<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Multinomial` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        logits: O0,
        num_samples: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(logits.into(), num_samples.into(), scope)
    }
    fn build_impl(
        &self,
        logits: crate::Output,
        num_samples: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Multinomial", |nd| {
            nd.add_input(logits);
            nd.add_input(num_samples);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.seed {
                nd.set_attr_int("seed", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed2 {
                nd.set_attr_int("seed2", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_dtype {
                nd.set_attr_type("output_dtype", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Multinomial' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        logits: crate::Output,
        num_samples: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<MultinomialInst> {
        let op = scope.new_operation("Multinomial", |builder| {
            builder.add_input(logits);
            builder.add_input(num_samples);
            if let ::std::option::Option::Some(value) = &self.seed {
                builder.set_attr_int("seed", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed2 {
                builder.set_attr_int("seed2", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_dtype {
                builder.set_attr_type("output_dtype", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(MultinomialInst { op })
    }
}
impl MultinomialInst {
    /// Returns the 'output' Output of this 'Multinomial' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'logits' Input of this 'Multinomial' operation.
    pub fn logits(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'num_samples' Input of this 'Multinomial' operation.
    pub fn num_samples(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<MultinomialInst> for crate::Operation {
    fn from(inst: MultinomialInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Multinomial::new().build(logits, num_samples, scope)`.
pub fn multinomial<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    logits: O0,
    num_samples: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Multinomial::new().build(logits, num_samples, scope)
}

/// Builder for the `MutableDenseHashTable` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct MutableDenseHashTable {
    container: ::std::option::Option<::std::string::String>,
    shared_name: ::std::option::Option<::std::string::String>,
    use_node_name_sharing: ::std::option::Option<bool>,
    key_dtype: ::std::option::Option<crate::DataType>,
    value_dtype: ::std::option::Option<crate::DataType>,
    value_shape: ::std::option::Option<crate::Shape>,
    initial_num_buckets: ::std::option::Option<i64>,
    max_load_factor: ::std::option::Option<f32>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'MutableDenseHashTable' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct MutableDenseHashTableInst {
    /// An instance of a fully built MutableDenseHashTable Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl MutableDenseHashTable {
    /// Creates a new `MutableDenseHashTable`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `container` attribute.
    pub fn container<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.container = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shared_name` attribute.
    pub fn shared_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.shared_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_node_name_sharing` attribute.
    pub fn use_node_name_sharing<ArgType: ::std::convert::Into<bool>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.use_node_name_sharing = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `key_dtype` attribute.
    pub fn key_dtype<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.key_dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `value_dtype` attribute.
    pub fn value_dtype<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.value_dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `value_shape` attribute.
    pub fn value_shape<ArgType: ::std::convert::Into<crate::Shape>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.value_shape = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `initial_num_buckets` attribute.
    pub fn initial_num_buckets<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.initial_num_buckets = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `max_load_factor` attribute.
    pub fn max_load_factor<ArgType: ::std::convert::Into<f32>>(mut self, value: ArgType) -> Self {
        self.max_load_factor = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `MutableDenseHashTable` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        empty_key: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(empty_key.into(), scope)
    }
    fn build_impl(
        &self,
        empty_key: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("MutableDenseHashTable", |nd| {
            nd.add_input(empty_key);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.container {
                nd.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                nd.set_attr_string("shared_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_node_name_sharing {
                nd.set_attr_bool("use_node_name_sharing", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.key_dtype {
                nd.set_attr_type("key_dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.value_dtype {
                nd.set_attr_type("value_dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.value_shape {
                nd.set_attr_shape("value_shape", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.initial_num_buckets {
                nd.set_attr_int("initial_num_buckets", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.max_load_factor {
                nd.set_attr_float("max_load_factor", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'MutableDenseHashTable' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        empty_key: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<MutableDenseHashTableInst> {
        let op = scope.new_operation("MutableDenseHashTable", |builder| {
            builder.add_input(empty_key);
            if let ::std::option::Option::Some(value) = &self.container {
                builder.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                builder.set_attr_string("shared_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_node_name_sharing {
                builder.set_attr_bool("use_node_name_sharing", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.key_dtype {
                builder.set_attr_type("key_dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.value_dtype {
                builder.set_attr_type("value_dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.value_shape {
                builder.set_attr_shape("value_shape", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.initial_num_buckets {
                builder.set_attr_int("initial_num_buckets", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.max_load_factor {
                builder.set_attr_float("max_load_factor", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(MutableDenseHashTableInst { op })
    }
}
impl MutableDenseHashTableInst {
    /// Returns the 'table_handle' Output of this 'MutableDenseHashTable' operation.
    pub fn table_handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'empty_key' Input of this 'MutableDenseHashTable' operation.
    pub fn empty_key(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<MutableDenseHashTableInst> for crate::Operation {
    fn from(inst: MutableDenseHashTableInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `MutableDenseHashTable::new().build(empty_key, scope)`.
pub fn mutable_dense_hash_table<O0: ::std::convert::Into<crate::Output>>(
    empty_key: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    MutableDenseHashTable::new().build(empty_key, scope)
}

/// Builder for the `MutableDenseHashTableV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct MutableDenseHashTableV2 {
    container: ::std::option::Option<::std::string::String>,
    shared_name: ::std::option::Option<::std::string::String>,
    use_node_name_sharing: ::std::option::Option<bool>,
    key_dtype: ::std::option::Option<crate::DataType>,
    value_dtype: ::std::option::Option<crate::DataType>,
    value_shape: ::std::option::Option<crate::Shape>,
    initial_num_buckets: ::std::option::Option<i64>,
    max_load_factor: ::std::option::Option<f32>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'MutableDenseHashTableV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct MutableDenseHashTableV2Inst {
    /// An instance of a fully built MutableDenseHashTableV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl MutableDenseHashTableV2 {
    /// Creates a new `MutableDenseHashTableV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `container` attribute.
    pub fn container<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.container = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shared_name` attribute.
    pub fn shared_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.shared_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_node_name_sharing` attribute.
    pub fn use_node_name_sharing<ArgType: ::std::convert::Into<bool>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.use_node_name_sharing = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `key_dtype` attribute.
    pub fn key_dtype<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.key_dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `value_dtype` attribute.
    pub fn value_dtype<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.value_dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `value_shape` attribute.
    pub fn value_shape<ArgType: ::std::convert::Into<crate::Shape>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.value_shape = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `initial_num_buckets` attribute.
    pub fn initial_num_buckets<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.initial_num_buckets = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `max_load_factor` attribute.
    pub fn max_load_factor<ArgType: ::std::convert::Into<f32>>(mut self, value: ArgType) -> Self {
        self.max_load_factor = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `MutableDenseHashTableV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        empty_key: O0,
        deleted_key: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(empty_key.into(), deleted_key.into(), scope)
    }
    fn build_impl(
        &self,
        empty_key: crate::Output,
        deleted_key: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("MutableDenseHashTableV2", |nd| {
            nd.add_input(empty_key);
            nd.add_input(deleted_key);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.container {
                nd.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                nd.set_attr_string("shared_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_node_name_sharing {
                nd.set_attr_bool("use_node_name_sharing", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.key_dtype {
                nd.set_attr_type("key_dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.value_dtype {
                nd.set_attr_type("value_dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.value_shape {
                nd.set_attr_shape("value_shape", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.initial_num_buckets {
                nd.set_attr_int("initial_num_buckets", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.max_load_factor {
                nd.set_attr_float("max_load_factor", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'MutableDenseHashTableV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        empty_key: crate::Output,
        deleted_key: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<MutableDenseHashTableV2Inst> {
        let op = scope.new_operation("MutableDenseHashTableV2", |builder| {
            builder.add_input(empty_key);
            builder.add_input(deleted_key);
            if let ::std::option::Option::Some(value) = &self.container {
                builder.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                builder.set_attr_string("shared_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_node_name_sharing {
                builder.set_attr_bool("use_node_name_sharing", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.key_dtype {
                builder.set_attr_type("key_dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.value_dtype {
                builder.set_attr_type("value_dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.value_shape {
                builder.set_attr_shape("value_shape", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.initial_num_buckets {
                builder.set_attr_int("initial_num_buckets", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.max_load_factor {
                builder.set_attr_float("max_load_factor", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(MutableDenseHashTableV2Inst { op })
    }
}
impl MutableDenseHashTableV2Inst {
    /// Returns the 'table_handle' Output of this 'MutableDenseHashTableV2' operation.
    pub fn table_handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'empty_key' Input of this 'MutableDenseHashTableV2' operation.
    pub fn empty_key(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'deleted_key' Input of this 'MutableDenseHashTableV2' operation.
    pub fn deleted_key(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<MutableDenseHashTableV2Inst> for crate::Operation {
    fn from(inst: MutableDenseHashTableV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `MutableDenseHashTableV2::new().build(empty_key, deleted_key, scope)`.
pub fn mutable_dense_hash_table_v2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    empty_key: O0,
    deleted_key: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    MutableDenseHashTableV2::new().build(empty_key, deleted_key, scope)
}

/// Builder for the `MutableHashTable` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct MutableHashTable {
    container: ::std::option::Option<::std::string::String>,
    shared_name: ::std::option::Option<::std::string::String>,
    use_node_name_sharing: ::std::option::Option<bool>,
    key_dtype: ::std::option::Option<crate::DataType>,
    value_dtype: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'MutableHashTable' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct MutableHashTableInst {
    /// An instance of a fully built MutableHashTable Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl MutableHashTable {
    /// Creates a new `MutableHashTable`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `container` attribute.
    pub fn container<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.container = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shared_name` attribute.
    pub fn shared_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.shared_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_node_name_sharing` attribute.
    pub fn use_node_name_sharing<ArgType: ::std::convert::Into<bool>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.use_node_name_sharing = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `key_dtype` attribute.
    pub fn key_dtype<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.key_dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `value_dtype` attribute.
    pub fn value_dtype<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.value_dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `MutableHashTable` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("MutableHashTable", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.container {
                nd.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                nd.set_attr_string("shared_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_node_name_sharing {
                nd.set_attr_bool("use_node_name_sharing", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.key_dtype {
                nd.set_attr_type("key_dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.value_dtype {
                nd.set_attr_type("value_dtype", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'MutableHashTable' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(&self, scope: &mut crate::Scope) -> crate::Result<MutableHashTableInst> {
        let op = scope.new_operation("MutableHashTable", |builder| {
            if let ::std::option::Option::Some(value) = &self.container {
                builder.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                builder.set_attr_string("shared_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_node_name_sharing {
                builder.set_attr_bool("use_node_name_sharing", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.key_dtype {
                builder.set_attr_type("key_dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.value_dtype {
                builder.set_attr_type("value_dtype", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(MutableHashTableInst { op })
    }
}
impl MutableHashTableInst {
    /// Returns the 'table_handle' Output of this 'MutableHashTable' operation.
    pub fn table_handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
}
impl From<MutableHashTableInst> for crate::Operation {
    fn from(inst: MutableHashTableInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `MutableHashTable::new().build(scope)`.
pub fn mutable_hash_table(scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
    MutableHashTable::new().build(scope)
}

/// Builder for the `MutableHashTableOfTensors` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct MutableHashTableOfTensors {
    container: ::std::option::Option<::std::string::String>,
    shared_name: ::std::option::Option<::std::string::String>,
    use_node_name_sharing: ::std::option::Option<bool>,
    key_dtype: ::std::option::Option<crate::DataType>,
    value_dtype: ::std::option::Option<crate::DataType>,
    value_shape: ::std::option::Option<crate::Shape>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'MutableHashTableOfTensors' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct MutableHashTableOfTensorsInst {
    /// An instance of a fully built MutableHashTableOfTensors Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl MutableHashTableOfTensors {
    /// Creates a new `MutableHashTableOfTensors`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `container` attribute.
    pub fn container<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.container = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shared_name` attribute.
    pub fn shared_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.shared_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_node_name_sharing` attribute.
    pub fn use_node_name_sharing<ArgType: ::std::convert::Into<bool>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.use_node_name_sharing = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `key_dtype` attribute.
    pub fn key_dtype<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.key_dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `value_dtype` attribute.
    pub fn value_dtype<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.value_dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `value_shape` attribute.
    pub fn value_shape<ArgType: ::std::convert::Into<crate::Shape>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.value_shape = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `MutableHashTableOfTensors` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("MutableHashTableOfTensors", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.container {
                nd.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                nd.set_attr_string("shared_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_node_name_sharing {
                nd.set_attr_bool("use_node_name_sharing", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.key_dtype {
                nd.set_attr_type("key_dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.value_dtype {
                nd.set_attr_type("value_dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.value_shape {
                nd.set_attr_shape("value_shape", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'MutableHashTableOfTensors' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        scope: &mut crate::Scope,
    ) -> crate::Result<MutableHashTableOfTensorsInst> {
        let op = scope.new_operation("MutableHashTableOfTensors", |builder| {
            if let ::std::option::Option::Some(value) = &self.container {
                builder.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                builder.set_attr_string("shared_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_node_name_sharing {
                builder.set_attr_bool("use_node_name_sharing", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.key_dtype {
                builder.set_attr_type("key_dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.value_dtype {
                builder.set_attr_type("value_dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.value_shape {
                builder.set_attr_shape("value_shape", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(MutableHashTableOfTensorsInst { op })
    }
}
impl MutableHashTableOfTensorsInst {
    /// Returns the 'table_handle' Output of this 'MutableHashTableOfTensors' operation.
    pub fn table_handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
}
impl From<MutableHashTableOfTensorsInst> for crate::Operation {
    fn from(inst: MutableHashTableOfTensorsInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `MutableHashTableOfTensors::new().build(scope)`.
pub fn mutable_hash_table_of_tensors(scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
    MutableHashTableOfTensors::new().build(scope)
}

/// Builder for the `MutableHashTableOfTensorsV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct MutableHashTableOfTensorsV2 {
    container: ::std::option::Option<::std::string::String>,
    shared_name: ::std::option::Option<::std::string::String>,
    use_node_name_sharing: ::std::option::Option<bool>,
    key_dtype: ::std::option::Option<crate::DataType>,
    value_dtype: ::std::option::Option<crate::DataType>,
    value_shape: ::std::option::Option<crate::Shape>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'MutableHashTableOfTensorsV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct MutableHashTableOfTensorsV2Inst {
    /// An instance of a fully built MutableHashTableOfTensorsV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl MutableHashTableOfTensorsV2 {
    /// Creates a new `MutableHashTableOfTensorsV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `container` attribute.
    pub fn container<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.container = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shared_name` attribute.
    pub fn shared_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.shared_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_node_name_sharing` attribute.
    pub fn use_node_name_sharing<ArgType: ::std::convert::Into<bool>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.use_node_name_sharing = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `key_dtype` attribute.
    pub fn key_dtype<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.key_dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `value_dtype` attribute.
    pub fn value_dtype<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.value_dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `value_shape` attribute.
    pub fn value_shape<ArgType: ::std::convert::Into<crate::Shape>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.value_shape = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `MutableHashTableOfTensorsV2` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("MutableHashTableOfTensorsV2", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.container {
                nd.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                nd.set_attr_string("shared_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_node_name_sharing {
                nd.set_attr_bool("use_node_name_sharing", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.key_dtype {
                nd.set_attr_type("key_dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.value_dtype {
                nd.set_attr_type("value_dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.value_shape {
                nd.set_attr_shape("value_shape", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'MutableHashTableOfTensorsV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        scope: &mut crate::Scope,
    ) -> crate::Result<MutableHashTableOfTensorsV2Inst> {
        let op = scope.new_operation("MutableHashTableOfTensorsV2", |builder| {
            if let ::std::option::Option::Some(value) = &self.container {
                builder.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                builder.set_attr_string("shared_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_node_name_sharing {
                builder.set_attr_bool("use_node_name_sharing", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.key_dtype {
                builder.set_attr_type("key_dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.value_dtype {
                builder.set_attr_type("value_dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.value_shape {
                builder.set_attr_shape("value_shape", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(MutableHashTableOfTensorsV2Inst { op })
    }
}
impl MutableHashTableOfTensorsV2Inst {
    /// Returns the 'table_handle' Output of this 'MutableHashTableOfTensorsV2' operation.
    pub fn table_handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
}
impl From<MutableHashTableOfTensorsV2Inst> for crate::Operation {
    fn from(inst: MutableHashTableOfTensorsV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `MutableHashTableOfTensorsV2::new().build(scope)`.
pub fn mutable_hash_table_of_tensors_v2(
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    MutableHashTableOfTensorsV2::new().build(scope)
}

/// Builder for the `MutableHashTableV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct MutableHashTableV2 {
    container: ::std::option::Option<::std::string::String>,
    shared_name: ::std::option::Option<::std::string::String>,
    use_node_name_sharing: ::std::option::Option<bool>,
    key_dtype: ::std::option::Option<crate::DataType>,
    value_dtype: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'MutableHashTableV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct MutableHashTableV2Inst {
    /// An instance of a fully built MutableHashTableV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl MutableHashTableV2 {
    /// Creates a new `MutableHashTableV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `container` attribute.
    pub fn container<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.container = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shared_name` attribute.
    pub fn shared_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.shared_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_node_name_sharing` attribute.
    pub fn use_node_name_sharing<ArgType: ::std::convert::Into<bool>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.use_node_name_sharing = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `key_dtype` attribute.
    pub fn key_dtype<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.key_dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `value_dtype` attribute.
    pub fn value_dtype<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.value_dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `MutableHashTableV2` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("MutableHashTableV2", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.container {
                nd.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                nd.set_attr_string("shared_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_node_name_sharing {
                nd.set_attr_bool("use_node_name_sharing", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.key_dtype {
                nd.set_attr_type("key_dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.value_dtype {
                nd.set_attr_type("value_dtype", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'MutableHashTableV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        scope: &mut crate::Scope,
    ) -> crate::Result<MutableHashTableV2Inst> {
        let op = scope.new_operation("MutableHashTableV2", |builder| {
            if let ::std::option::Option::Some(value) = &self.container {
                builder.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                builder.set_attr_string("shared_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_node_name_sharing {
                builder.set_attr_bool("use_node_name_sharing", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.key_dtype {
                builder.set_attr_type("key_dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.value_dtype {
                builder.set_attr_type("value_dtype", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(MutableHashTableV2Inst { op })
    }
}
impl MutableHashTableV2Inst {
    /// Returns the 'table_handle' Output of this 'MutableHashTableV2' operation.
    pub fn table_handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
}
impl From<MutableHashTableV2Inst> for crate::Operation {
    fn from(inst: MutableHashTableV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `MutableHashTableV2::new().build(scope)`.
pub fn mutable_hash_table_v2(scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
    MutableHashTableV2::new().build(scope)
}

/// Builder for the `MutexLock` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct MutexLock {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'MutexLock' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct MutexLockInst {
    /// An instance of a fully built MutexLock Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl MutexLock {
    /// Creates a new `MutexLock`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `MutexLock` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        mutex: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(mutex.into(), scope)
    }
    fn build_impl(
        &self,
        mutex: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("MutexLock", |nd| {
            nd.add_input(mutex);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'MutexLock' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        mutex: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<MutexLockInst> {
        let op = scope.new_operation("MutexLock", |builder| {
            builder.add_input(mutex);
            ::std::result::Result::Ok(())
        })?;
        Ok(MutexLockInst { op })
    }
}
impl MutexLockInst {
    /// Returns the 'mutex_lock' Output of this 'MutexLock' operation.
    pub fn mutex_lock(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'mutex' Input of this 'MutexLock' operation.
    pub fn mutex(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<MutexLockInst> for crate::Operation {
    fn from(inst: MutexLockInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `MutexLock::new().build(mutex, scope)`.
pub fn mutex_lock<O0: ::std::convert::Into<crate::Output>>(
    mutex: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    MutexLock::new().build(mutex, scope)
}

/// Builder for the `MutexV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct MutexV2 {
    container: ::std::option::Option<::std::string::String>,
    shared_name: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'MutexV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct MutexV2Inst {
    /// An instance of a fully built MutexV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl MutexV2 {
    /// Creates a new `MutexV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `container` attribute.
    pub fn container<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.container = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shared_name` attribute.
    pub fn shared_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.shared_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `MutexV2` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("MutexV2", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.container {
                nd.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                nd.set_attr_string("shared_name", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'MutexV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(&self, scope: &mut crate::Scope) -> crate::Result<MutexV2Inst> {
        let op = scope.new_operation("MutexV2", |builder| {
            if let ::std::option::Option::Some(value) = &self.container {
                builder.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                builder.set_attr_string("shared_name", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(MutexV2Inst { op })
    }
}
impl MutexV2Inst {
    /// Returns the 'resource' Output of this 'MutexV2' operation.
    pub fn resource(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
}
impl From<MutexV2Inst> for crate::Operation {
    fn from(inst: MutexV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `MutexV2::new().build(scope)`.
pub fn mutex_v2(scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
    MutexV2::new().build(scope)
}

/// Builder for the `NcclAllReduce` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct NcclAllReduce {
    reduction: ::std::option::Option<::std::string::String>,
    T: ::std::option::Option<crate::DataType>,
    num_devices: ::std::option::Option<i64>,
    shared_name: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'NcclAllReduce' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct NcclAllReduceInst {
    /// An instance of a fully built NcclAllReduce Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl NcclAllReduce {
    /// Creates a new `NcclAllReduce`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `reduction` attribute.
    pub fn reduction<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.reduction = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `num_devices` attribute.
    pub fn num_devices<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.num_devices = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shared_name` attribute.
    pub fn shared_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.shared_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `NcclAllReduce` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("NcclAllReduce", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.reduction {
                nd.set_attr_string("reduction", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_devices {
                nd.set_attr_int("num_devices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                nd.set_attr_string("shared_name", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'NcclAllReduce' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<NcclAllReduceInst> {
        let op = scope.new_operation("NcclAllReduce", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.reduction {
                builder.set_attr_string("reduction", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_devices {
                builder.set_attr_int("num_devices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                builder.set_attr_string("shared_name", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(NcclAllReduceInst { op })
    }
}
impl NcclAllReduceInst {
    /// Returns the 'data' Output of this 'NcclAllReduce' operation.
    pub fn data(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'NcclAllReduce' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<NcclAllReduceInst> for crate::Operation {
    fn from(inst: NcclAllReduceInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `NcclAllReduce::new().build(input, scope)`.
pub fn nccl_all_reduce<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    NcclAllReduce::new().build(input, scope)
}

/// Builder for the `NcclBroadcast` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct NcclBroadcast {
    T: ::std::option::Option<crate::DataType>,
    shape: ::std::option::Option<crate::Shape>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'NcclBroadcast' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct NcclBroadcastInst {
    /// An instance of a fully built NcclBroadcast Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl NcclBroadcast {
    /// Creates a new `NcclBroadcast`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shape` attribute.
    pub fn shape<ArgType: ::std::convert::Into<crate::Shape>>(mut self, value: ArgType) -> Self {
        self.shape = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `NcclBroadcast` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("NcclBroadcast", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shape {
                nd.set_attr_shape("shape", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'NcclBroadcast' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<NcclBroadcastInst> {
        let op = scope.new_operation("NcclBroadcast", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shape {
                builder.set_attr_shape("shape", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(NcclBroadcastInst { op })
    }
}
impl NcclBroadcastInst {
    /// Returns the 'output' Output of this 'NcclBroadcast' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'NcclBroadcast' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<NcclBroadcastInst> for crate::Operation {
    fn from(inst: NcclBroadcastInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `NcclBroadcast::new().build(input, scope)`.
pub fn nccl_broadcast<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    NcclBroadcast::new().build(input, scope)
}

/// Builder for the `NcclReduce` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct NcclReduce {
    reduction: ::std::option::Option<::std::string::String>,
    T: ::std::option::Option<crate::DataType>,
    num_devices: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'NcclReduce' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct NcclReduceInst {
    /// An instance of a fully built NcclReduce Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl NcclReduce {
    /// Creates a new `NcclReduce`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `reduction` attribute.
    pub fn reduction<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.reduction = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `num_devices` attribute.
    pub fn num_devices<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.num_devices = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `NcclReduce` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("NcclReduce", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.reduction {
                nd.set_attr_string("reduction", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_devices {
                nd.set_attr_int("num_devices", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'NcclReduce' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: Vec<crate::Output>,
        scope: &mut crate::Scope,
    ) -> crate::Result<NcclReduceInst> {
        let op = scope.new_operation("NcclReduce", |builder| {
            builder.add_input_list(&input);
            if let ::std::option::Option::Some(value) = &self.reduction {
                builder.set_attr_string("reduction", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            builder.set_attr_int("num_devices", input.clone().len() as i64)?;
            ::std::result::Result::Ok(())
        })?;
        Ok(NcclReduceInst { op })
    }
}
impl NcclReduceInst {
    /// Returns the 'data' Output of this 'NcclReduce' operation.
    pub fn data(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns a Vector of input for 'input' Input of this NcclReduce operation.
    pub fn input(&self) -> crate::Result<Vec<crate::Input>> {
        let mut Inputs = vec![];
        for i in 0..self.op.get_attr_int("num_devices")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
}
impl From<NcclReduceInst> for crate::Operation {
    fn from(inst: NcclReduceInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `NcclReduce::new().build(input, scope)`.
pub fn nccl_reduce<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    NcclReduce::new().build(input, scope)
}

/// Builder for the `Ndtri` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Ndtri {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Ndtri' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct NdtriInst {
    /// An instance of a fully built Ndtri Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Ndtri {
    /// Creates a new `Ndtri`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Ndtri` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        x: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Ndtri", |nd| {
            nd.add_input(x);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Ndtri' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<NdtriInst> {
        let op = scope.new_operation("Ndtri", |builder| {
            builder.add_input(x);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(NdtriInst { op })
    }
}
impl NdtriInst {
    /// Returns the 'y' Output of this 'Ndtri' operation.
    pub fn y(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'Ndtri' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<NdtriInst> for crate::Operation {
    fn from(inst: NdtriInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Ndtri::new().build(x, scope)`.
pub fn ndtri<O0: ::std::convert::Into<crate::Output>>(
    x: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Ndtri::new().build(x, scope)
}

/// Builder for the `NearestNeighbors` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct NearestNeighbors {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'NearestNeighbors' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct NearestNeighborsInst {
    /// An instance of a fully built NearestNeighbors Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl NearestNeighbors {
    /// Creates a new `NearestNeighbors`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `NearestNeighbors` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        points: O0,
        centers: O1,
        k: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(points.into(), centers.into(), k.into(), scope)
    }
    fn build_impl(
        &self,
        points: crate::Output,
        centers: crate::Output,
        k: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("NearestNeighbors", |nd| {
            nd.add_input(points);
            nd.add_input(centers);
            nd.add_input(k);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'NearestNeighbors' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        points: crate::Output,
        centers: crate::Output,
        k: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<NearestNeighborsInst> {
        let op = scope.new_operation("NearestNeighbors", |builder| {
            builder.add_input(points);
            builder.add_input(centers);
            builder.add_input(k);
            ::std::result::Result::Ok(())
        })?;
        Ok(NearestNeighborsInst { op })
    }
}
impl NearestNeighborsInst {
    /// Returns the 'nearest_center_indices' Output of this 'NearestNeighbors' operation.
    pub fn nearest_center_indices(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'nearest_center_distances' Output of this 'NearestNeighbors' operation.
    pub fn nearest_center_distances(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'points' Input of this 'NearestNeighbors' operation.
    pub fn points(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'centers' Input of this 'NearestNeighbors' operation.
    pub fn centers(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'k' Input of this 'NearestNeighbors' operation.
    pub fn k(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<NearestNeighborsInst> for crate::Operation {
    fn from(inst: NearestNeighborsInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `NearestNeighbors::new().build(points, centers, k, scope)`.
pub fn nearest_neighbors<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    points: O0,
    centers: O1,
    k: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    NearestNeighbors::new().build(points, centers, k, scope)
}

/// Builder for the `Neg` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Neg {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Neg' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct NegInst {
    /// An instance of a fully built Neg Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Neg {
    /// Creates a new `Neg`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Neg` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        x: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Neg", |nd| {
            nd.add_input(x);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Neg' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<NegInst> {
        let op = scope.new_operation("Neg", |builder| {
            builder.add_input(x);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(NegInst { op })
    }
}
impl NegInst {
    /// Returns the 'y' Output of this 'Neg' operation.
    pub fn y(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'Neg' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<NegInst> for crate::Operation {
    fn from(inst: NegInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Neg::new().build(x, scope)`.
pub fn neg<O0: ::std::convert::Into<crate::Output>>(
    x: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Neg::new().build(x, scope)
}

/// Builder for the `NegTrain` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct NegTrain {
    vocab_count: ::std::option::Option<::std::vec::Vec<i64>>,
    num_negative_samples: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'NegTrain' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct NegTrainInst {
    /// An instance of a fully built NegTrain Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl NegTrain {
    /// Creates a new `NegTrain`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `vocab_count` attribute.
    pub fn vocab_count<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.vocab_count = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `num_negative_samples` attribute.
    pub fn num_negative_samples<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.num_negative_samples = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `NegTrain` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
    >(
        &self,
        w_in: O0,
        w_out: O1,
        examples: O2,
        labels: O3,
        lr: O4,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            w_in.into(),
            w_out.into(),
            examples.into(),
            labels.into(),
            lr.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        w_in: crate::Output,
        w_out: crate::Output,
        examples: crate::Output,
        labels: crate::Output,
        lr: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("NegTrain", |nd| {
            nd.add_input(w_in);
            nd.add_input(w_out);
            nd.add_input(examples);
            nd.add_input(labels);
            nd.add_input(lr);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.vocab_count {
                nd.set_attr_int_list("vocab_count", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_negative_samples {
                nd.set_attr_int("num_negative_samples", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'NegTrain' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        w_in: crate::Output,
        w_out: crate::Output,
        examples: crate::Output,
        labels: crate::Output,
        lr: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<NegTrainInst> {
        let op = scope.new_operation("NegTrain", |builder| {
            builder.add_input(w_in);
            builder.add_input(w_out);
            builder.add_input(examples);
            builder.add_input(labels);
            builder.add_input(lr);
            if let ::std::option::Option::Some(value) = &self.vocab_count {
                builder.set_attr_int_list("vocab_count", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_negative_samples {
                builder.set_attr_int("num_negative_samples", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(NegTrainInst { op })
    }
}
impl NegTrainInst {
    /// Returns the 'w_in' Input of this 'NegTrain' operation.
    pub fn w_in(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'w_out' Input of this 'NegTrain' operation.
    pub fn w_out(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'examples' Input of this 'NegTrain' operation.
    pub fn examples(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'labels' Input of this 'NegTrain' operation.
    pub fn labels(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'lr' Input of this 'NegTrain' operation.
    pub fn lr(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
}
impl From<NegTrainInst> for crate::Operation {
    fn from(inst: NegTrainInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `NegTrain::new().build(w_in, w_out, examples, labels, lr, scope)`.
pub fn neg_train<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
>(
    w_in: O0,
    w_out: O1,
    examples: O2,
    labels: O3,
    lr: O4,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    NegTrain::new().build(w_in, w_out, examples, labels, lr, scope)
}

/// Builder for the `NextAfter` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct NextAfter {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'NextAfter' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct NextAfterInst {
    /// An instance of a fully built NextAfter Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl NextAfter {
    /// Creates a new `NextAfter`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `NextAfter` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        x1: O0,
        x2: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x1.into(), x2.into(), scope)
    }
    fn build_impl(
        &self,
        x1: crate::Output,
        x2: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("NextAfter", |nd| {
            nd.add_input(x1);
            nd.add_input(x2);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'NextAfter' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x1: crate::Output,
        x2: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<NextAfterInst> {
        let op = scope.new_operation("NextAfter", |builder| {
            builder.add_input(x1);
            builder.add_input(x2);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(NextAfterInst { op })
    }
}
impl NextAfterInst {
    /// Returns the 'output' Output of this 'NextAfter' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x1' Input of this 'NextAfter' operation.
    pub fn x1(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'x2' Input of this 'NextAfter' operation.
    pub fn x2(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<NextAfterInst> for crate::Operation {
    fn from(inst: NextAfterInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `NextAfter::new().build(x1, x2, scope)`.
pub fn next_after<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    x1: O0,
    x2: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    NextAfter::new().build(x1, x2, scope)
}

/// Builder for the `NextIteration` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct NextIteration {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'NextIteration' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct NextIterationInst {
    /// An instance of a fully built NextIteration Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl NextIteration {
    /// Creates a new `NextIteration`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `NextIteration` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        data: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(data.into(), scope)
    }
    fn build_impl(
        &self,
        data: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("NextIteration", |nd| {
            nd.add_input(data);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'NextIteration' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        data: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<NextIterationInst> {
        let op = scope.new_operation("NextIteration", |builder| {
            builder.add_input(data);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(NextIterationInst { op })
    }
}
impl NextIterationInst {
    /// Returns the 'output' Output of this 'NextIteration' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'data' Input of this 'NextIteration' operation.
    pub fn data(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<NextIterationInst> for crate::Operation {
    fn from(inst: NextIterationInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `NextIteration::new().build(data, scope)`.
pub fn next_iteration<O0: ::std::convert::Into<crate::Output>>(
    data: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    NextIteration::new().build(data, scope)
}

/// Builder for the `NoOp` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct NoOp {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'NoOp' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct NoOpInst {
    /// An instance of a fully built NoOp Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl NoOp {
    /// Creates a new `NoOp`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `NoOp` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("NoOp", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'NoOp' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(&self, scope: &mut crate::Scope) -> crate::Result<NoOpInst> {
        let op = scope.new_operation("NoOp", |builder| ::std::result::Result::Ok(()))?;
        Ok(NoOpInst { op })
    }
}
impl NoOpInst {}
impl From<NoOpInst> for crate::Operation {
    fn from(inst: NoOpInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `NoOp::new().build(scope)`.
pub fn no_op(scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
    NoOp::new().build(scope)
}

/// Builder for the `NonDeterministicInts` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct NonDeterministicInts {
    dtype: ::std::option::Option<crate::DataType>,
    shape_dtype: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'NonDeterministicInts' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct NonDeterministicIntsInst {
    /// An instance of a fully built NonDeterministicInts Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl NonDeterministicInts {
    /// Creates a new `NonDeterministicInts`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `dtype` attribute.
    pub fn dtype<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shape_dtype` attribute.
    pub fn shape_dtype<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.shape_dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `NonDeterministicInts` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        shape: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(shape.into(), scope)
    }
    fn build_impl(
        &self,
        shape: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("NonDeterministicInts", |nd| {
            nd.add_input(shape);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                nd.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shape_dtype {
                nd.set_attr_type("shape_dtype", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'NonDeterministicInts' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        shape: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<NonDeterministicIntsInst> {
        let op = scope.new_operation("NonDeterministicInts", |builder| {
            builder.add_input(shape);
            if let ::std::option::Option::Some(value) = &self.dtype {
                builder.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shape_dtype {
                builder.set_attr_type("shape_dtype", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(NonDeterministicIntsInst { op })
    }
}
impl NonDeterministicIntsInst {
    /// Returns the 'output' Output of this 'NonDeterministicInts' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'shape' Input of this 'NonDeterministicInts' operation.
    pub fn shape(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<NonDeterministicIntsInst> for crate::Operation {
    fn from(inst: NonDeterministicIntsInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `NonDeterministicInts::new().build(shape, scope)`.
pub fn non_deterministic_ints<O0: ::std::convert::Into<crate::Output>>(
    shape: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    NonDeterministicInts::new().build(shape, scope)
}

/// Builder for the `NonMaxSuppression` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct NonMaxSuppression {
    iou_threshold: ::std::option::Option<f32>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'NonMaxSuppression' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct NonMaxSuppressionInst {
    /// An instance of a fully built NonMaxSuppression Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl NonMaxSuppression {
    /// Creates a new `NonMaxSuppression`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `iou_threshold` attribute.
    pub fn iou_threshold<ArgType: ::std::convert::Into<f32>>(mut self, value: ArgType) -> Self {
        self.iou_threshold = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `NonMaxSuppression` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        boxes: O0,
        scores: O1,
        max_output_size: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(boxes.into(), scores.into(), max_output_size.into(), scope)
    }
    fn build_impl(
        &self,
        boxes: crate::Output,
        scores: crate::Output,
        max_output_size: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("NonMaxSuppression", |nd| {
            nd.add_input(boxes);
            nd.add_input(scores);
            nd.add_input(max_output_size);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.iou_threshold {
                nd.set_attr_float("iou_threshold", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'NonMaxSuppression' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        boxes: crate::Output,
        scores: crate::Output,
        max_output_size: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<NonMaxSuppressionInst> {
        let op = scope.new_operation("NonMaxSuppression", |builder| {
            builder.add_input(boxes);
            builder.add_input(scores);
            builder.add_input(max_output_size);
            if let ::std::option::Option::Some(value) = &self.iou_threshold {
                builder.set_attr_float("iou_threshold", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(NonMaxSuppressionInst { op })
    }
}
impl NonMaxSuppressionInst {
    /// Returns the 'selected_indices' Output of this 'NonMaxSuppression' operation.
    pub fn selected_indices(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'boxes' Input of this 'NonMaxSuppression' operation.
    pub fn boxes(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'scores' Input of this 'NonMaxSuppression' operation.
    pub fn scores(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'max_output_size' Input of this 'NonMaxSuppression' operation.
    pub fn max_output_size(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<NonMaxSuppressionInst> for crate::Operation {
    fn from(inst: NonMaxSuppressionInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `NonMaxSuppression::new().build(boxes, scores, max_output_size, scope)`.
pub fn non_max_suppression<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    boxes: O0,
    scores: O1,
    max_output_size: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    NonMaxSuppression::new().build(boxes, scores, max_output_size, scope)
}

/// Builder for the `NonMaxSuppressionV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct NonMaxSuppressionV2 {
    T: ::std::option::Option<crate::DataType>,
    T_threshold: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'NonMaxSuppressionV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct NonMaxSuppressionV2Inst {
    /// An instance of a fully built NonMaxSuppressionV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl NonMaxSuppressionV2 {
    /// Creates a new `NonMaxSuppressionV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T_threshold` attribute.
    pub fn T_threshold<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.T_threshold = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `NonMaxSuppressionV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
    >(
        &self,
        boxes: O0,
        scores: O1,
        max_output_size: O2,
        iou_threshold: O3,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            boxes.into(),
            scores.into(),
            max_output_size.into(),
            iou_threshold.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        boxes: crate::Output,
        scores: crate::Output,
        max_output_size: crate::Output,
        iou_threshold: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("NonMaxSuppressionV2", |nd| {
            nd.add_input(boxes);
            nd.add_input(scores);
            nd.add_input(max_output_size);
            nd.add_input(iou_threshold);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T_threshold {
                nd.set_attr_type("T_threshold", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'NonMaxSuppressionV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        boxes: crate::Output,
        scores: crate::Output,
        max_output_size: crate::Output,
        iou_threshold: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<NonMaxSuppressionV2Inst> {
        let op = scope.new_operation("NonMaxSuppressionV2", |builder| {
            builder.add_input(boxes);
            builder.add_input(scores);
            builder.add_input(max_output_size);
            builder.add_input(iou_threshold);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T_threshold {
                builder.set_attr_type("T_threshold", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(NonMaxSuppressionV2Inst { op })
    }
}
impl NonMaxSuppressionV2Inst {
    /// Returns the 'selected_indices' Output of this 'NonMaxSuppressionV2' operation.
    pub fn selected_indices(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'boxes' Input of this 'NonMaxSuppressionV2' operation.
    pub fn boxes(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'scores' Input of this 'NonMaxSuppressionV2' operation.
    pub fn scores(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'max_output_size' Input of this 'NonMaxSuppressionV2' operation.
    pub fn max_output_size(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'iou_threshold' Input of this 'NonMaxSuppressionV2' operation.
    pub fn iou_threshold(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
}
impl From<NonMaxSuppressionV2Inst> for crate::Operation {
    fn from(inst: NonMaxSuppressionV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `NonMaxSuppressionV2::new().build(boxes, scores, max_output_size, iou_threshold, scope)`.
pub fn non_max_suppression_v2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
>(
    boxes: O0,
    scores: O1,
    max_output_size: O2,
    iou_threshold: O3,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    NonMaxSuppressionV2::new().build(boxes, scores, max_output_size, iou_threshold, scope)
}

/// Builder for the `NonMaxSuppressionV3` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct NonMaxSuppressionV3 {
    T: ::std::option::Option<crate::DataType>,
    T_threshold: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'NonMaxSuppressionV3' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct NonMaxSuppressionV3Inst {
    /// An instance of a fully built NonMaxSuppressionV3 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl NonMaxSuppressionV3 {
    /// Creates a new `NonMaxSuppressionV3`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T_threshold` attribute.
    pub fn T_threshold<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.T_threshold = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `NonMaxSuppressionV3` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
    >(
        &self,
        boxes: O0,
        scores: O1,
        max_output_size: O2,
        iou_threshold: O3,
        score_threshold: O4,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            boxes.into(),
            scores.into(),
            max_output_size.into(),
            iou_threshold.into(),
            score_threshold.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        boxes: crate::Output,
        scores: crate::Output,
        max_output_size: crate::Output,
        iou_threshold: crate::Output,
        score_threshold: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("NonMaxSuppressionV3", |nd| {
            nd.add_input(boxes);
            nd.add_input(scores);
            nd.add_input(max_output_size);
            nd.add_input(iou_threshold);
            nd.add_input(score_threshold);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T_threshold {
                nd.set_attr_type("T_threshold", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'NonMaxSuppressionV3' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        boxes: crate::Output,
        scores: crate::Output,
        max_output_size: crate::Output,
        iou_threshold: crate::Output,
        score_threshold: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<NonMaxSuppressionV3Inst> {
        let op = scope.new_operation("NonMaxSuppressionV3", |builder| {
            builder.add_input(boxes);
            builder.add_input(scores);
            builder.add_input(max_output_size);
            builder.add_input(iou_threshold);
            builder.add_input(score_threshold);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T_threshold {
                builder.set_attr_type("T_threshold", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(NonMaxSuppressionV3Inst { op })
    }
}
impl NonMaxSuppressionV3Inst {
    /// Returns the 'selected_indices' Output of this 'NonMaxSuppressionV3' operation.
    pub fn selected_indices(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'boxes' Input of this 'NonMaxSuppressionV3' operation.
    pub fn boxes(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'scores' Input of this 'NonMaxSuppressionV3' operation.
    pub fn scores(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'max_output_size' Input of this 'NonMaxSuppressionV3' operation.
    pub fn max_output_size(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'iou_threshold' Input of this 'NonMaxSuppressionV3' operation.
    pub fn iou_threshold(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'score_threshold' Input of this 'NonMaxSuppressionV3' operation.
    pub fn score_threshold(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
}
impl From<NonMaxSuppressionV3Inst> for crate::Operation {
    fn from(inst: NonMaxSuppressionV3Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `NonMaxSuppressionV3::new().build(boxes, scores, max_output_size, iou_threshold, score_threshold, scope)`.
pub fn non_max_suppression_v3<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
>(
    boxes: O0,
    scores: O1,
    max_output_size: O2,
    iou_threshold: O3,
    score_threshold: O4,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    NonMaxSuppressionV3::new().build(
        boxes,
        scores,
        max_output_size,
        iou_threshold,
        score_threshold,
        scope,
    )
}

/// Builder for the `NonMaxSuppressionV4` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct NonMaxSuppressionV4 {
    T: ::std::option::Option<crate::DataType>,
    T_threshold: ::std::option::Option<crate::DataType>,
    pad_to_max_output_size: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'NonMaxSuppressionV4' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct NonMaxSuppressionV4Inst {
    /// An instance of a fully built NonMaxSuppressionV4 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl NonMaxSuppressionV4 {
    /// Creates a new `NonMaxSuppressionV4`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T_threshold` attribute.
    pub fn T_threshold<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.T_threshold = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `pad_to_max_output_size` attribute.
    pub fn pad_to_max_output_size<ArgType: ::std::convert::Into<bool>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.pad_to_max_output_size = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `NonMaxSuppressionV4` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
    >(
        &self,
        boxes: O0,
        scores: O1,
        max_output_size: O2,
        iou_threshold: O3,
        score_threshold: O4,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            boxes.into(),
            scores.into(),
            max_output_size.into(),
            iou_threshold.into(),
            score_threshold.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        boxes: crate::Output,
        scores: crate::Output,
        max_output_size: crate::Output,
        iou_threshold: crate::Output,
        score_threshold: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("NonMaxSuppressionV4", |nd| {
            nd.add_input(boxes);
            nd.add_input(scores);
            nd.add_input(max_output_size);
            nd.add_input(iou_threshold);
            nd.add_input(score_threshold);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T_threshold {
                nd.set_attr_type("T_threshold", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.pad_to_max_output_size {
                nd.set_attr_bool("pad_to_max_output_size", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'NonMaxSuppressionV4' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        boxes: crate::Output,
        scores: crate::Output,
        max_output_size: crate::Output,
        iou_threshold: crate::Output,
        score_threshold: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<NonMaxSuppressionV4Inst> {
        let op = scope.new_operation("NonMaxSuppressionV4", |builder| {
            builder.add_input(boxes);
            builder.add_input(scores);
            builder.add_input(max_output_size);
            builder.add_input(iou_threshold);
            builder.add_input(score_threshold);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T_threshold {
                builder.set_attr_type("T_threshold", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.pad_to_max_output_size {
                builder.set_attr_bool("pad_to_max_output_size", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(NonMaxSuppressionV4Inst { op })
    }
}
impl NonMaxSuppressionV4Inst {
    /// Returns the 'selected_indices' Output of this 'NonMaxSuppressionV4' operation.
    pub fn selected_indices(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'valid_outputs' Output of this 'NonMaxSuppressionV4' operation.
    pub fn valid_outputs(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'boxes' Input of this 'NonMaxSuppressionV4' operation.
    pub fn boxes(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'scores' Input of this 'NonMaxSuppressionV4' operation.
    pub fn scores(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'max_output_size' Input of this 'NonMaxSuppressionV4' operation.
    pub fn max_output_size(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'iou_threshold' Input of this 'NonMaxSuppressionV4' operation.
    pub fn iou_threshold(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'score_threshold' Input of this 'NonMaxSuppressionV4' operation.
    pub fn score_threshold(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
}
impl From<NonMaxSuppressionV4Inst> for crate::Operation {
    fn from(inst: NonMaxSuppressionV4Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `NonMaxSuppressionV4::new().build(boxes, scores, max_output_size, iou_threshold, score_threshold, scope)`.
pub fn non_max_suppression_v4<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
>(
    boxes: O0,
    scores: O1,
    max_output_size: O2,
    iou_threshold: O3,
    score_threshold: O4,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    NonMaxSuppressionV4::new().build(
        boxes,
        scores,
        max_output_size,
        iou_threshold,
        score_threshold,
        scope,
    )
}

/// Builder for the `NonMaxSuppressionV5` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct NonMaxSuppressionV5 {
    T: ::std::option::Option<crate::DataType>,
    pad_to_max_output_size: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'NonMaxSuppressionV5' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct NonMaxSuppressionV5Inst {
    /// An instance of a fully built NonMaxSuppressionV5 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl NonMaxSuppressionV5 {
    /// Creates a new `NonMaxSuppressionV5`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `pad_to_max_output_size` attribute.
    pub fn pad_to_max_output_size<ArgType: ::std::convert::Into<bool>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.pad_to_max_output_size = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `NonMaxSuppressionV5` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
    >(
        &self,
        boxes: O0,
        scores: O1,
        max_output_size: O2,
        iou_threshold: O3,
        score_threshold: O4,
        soft_nms_sigma: O5,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            boxes.into(),
            scores.into(),
            max_output_size.into(),
            iou_threshold.into(),
            score_threshold.into(),
            soft_nms_sigma.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        boxes: crate::Output,
        scores: crate::Output,
        max_output_size: crate::Output,
        iou_threshold: crate::Output,
        score_threshold: crate::Output,
        soft_nms_sigma: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("NonMaxSuppressionV5", |nd| {
            nd.add_input(boxes);
            nd.add_input(scores);
            nd.add_input(max_output_size);
            nd.add_input(iou_threshold);
            nd.add_input(score_threshold);
            nd.add_input(soft_nms_sigma);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.pad_to_max_output_size {
                nd.set_attr_bool("pad_to_max_output_size", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'NonMaxSuppressionV5' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        boxes: crate::Output,
        scores: crate::Output,
        max_output_size: crate::Output,
        iou_threshold: crate::Output,
        score_threshold: crate::Output,
        soft_nms_sigma: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<NonMaxSuppressionV5Inst> {
        let op = scope.new_operation("NonMaxSuppressionV5", |builder| {
            builder.add_input(boxes);
            builder.add_input(scores);
            builder.add_input(max_output_size);
            builder.add_input(iou_threshold);
            builder.add_input(score_threshold);
            builder.add_input(soft_nms_sigma);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.pad_to_max_output_size {
                builder.set_attr_bool("pad_to_max_output_size", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(NonMaxSuppressionV5Inst { op })
    }
}
impl NonMaxSuppressionV5Inst {
    /// Returns the 'selected_indices' Output of this 'NonMaxSuppressionV5' operation.
    pub fn selected_indices(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'selected_scores' Output of this 'NonMaxSuppressionV5' operation.
    pub fn selected_scores(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'valid_outputs' Output of this 'NonMaxSuppressionV5' operation.
    pub fn valid_outputs(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns the 'boxes' Input of this 'NonMaxSuppressionV5' operation.
    pub fn boxes(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'scores' Input of this 'NonMaxSuppressionV5' operation.
    pub fn scores(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'max_output_size' Input of this 'NonMaxSuppressionV5' operation.
    pub fn max_output_size(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'iou_threshold' Input of this 'NonMaxSuppressionV5' operation.
    pub fn iou_threshold(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'score_threshold' Input of this 'NonMaxSuppressionV5' operation.
    pub fn score_threshold(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
    /// Returns the 'soft_nms_sigma' Input of this 'NonMaxSuppressionV5' operation.
    pub fn soft_nms_sigma(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 5,
        }
    }
}
impl From<NonMaxSuppressionV5Inst> for crate::Operation {
    fn from(inst: NonMaxSuppressionV5Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `NonMaxSuppressionV5::new().build(boxes, scores, max_output_size, iou_threshold, score_threshold, soft_nms_sigma, scope)`.
pub fn non_max_suppression_v5<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
>(
    boxes: O0,
    scores: O1,
    max_output_size: O2,
    iou_threshold: O3,
    score_threshold: O4,
    soft_nms_sigma: O5,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    NonMaxSuppressionV5::new().build(
        boxes,
        scores,
        max_output_size,
        iou_threshold,
        score_threshold,
        soft_nms_sigma,
        scope,
    )
}

/// Builder for the `NonMaxSuppressionWithOverlaps` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct NonMaxSuppressionWithOverlaps {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'NonMaxSuppressionWithOverlaps' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct NonMaxSuppressionWithOverlapsInst {
    /// An instance of a fully built NonMaxSuppressionWithOverlaps Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl NonMaxSuppressionWithOverlaps {
    /// Creates a new `NonMaxSuppressionWithOverlaps`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `NonMaxSuppressionWithOverlaps` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
    >(
        &self,
        overlaps: O0,
        scores: O1,
        max_output_size: O2,
        overlap_threshold: O3,
        score_threshold: O4,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            overlaps.into(),
            scores.into(),
            max_output_size.into(),
            overlap_threshold.into(),
            score_threshold.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        overlaps: crate::Output,
        scores: crate::Output,
        max_output_size: crate::Output,
        overlap_threshold: crate::Output,
        score_threshold: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("NonMaxSuppressionWithOverlaps", |nd| {
            nd.add_input(overlaps);
            nd.add_input(scores);
            nd.add_input(max_output_size);
            nd.add_input(overlap_threshold);
            nd.add_input(score_threshold);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'NonMaxSuppressionWithOverlaps' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        overlaps: crate::Output,
        scores: crate::Output,
        max_output_size: crate::Output,
        overlap_threshold: crate::Output,
        score_threshold: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<NonMaxSuppressionWithOverlapsInst> {
        let op = scope.new_operation("NonMaxSuppressionWithOverlaps", |builder| {
            builder.add_input(overlaps);
            builder.add_input(scores);
            builder.add_input(max_output_size);
            builder.add_input(overlap_threshold);
            builder.add_input(score_threshold);
            ::std::result::Result::Ok(())
        })?;
        Ok(NonMaxSuppressionWithOverlapsInst { op })
    }
}
impl NonMaxSuppressionWithOverlapsInst {
    /// Returns the 'selected_indices' Output of this 'NonMaxSuppressionWithOverlaps' operation.
    pub fn selected_indices(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'overlaps' Input of this 'NonMaxSuppressionWithOverlaps' operation.
    pub fn overlaps(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'scores' Input of this 'NonMaxSuppressionWithOverlaps' operation.
    pub fn scores(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'max_output_size' Input of this 'NonMaxSuppressionWithOverlaps' operation.
    pub fn max_output_size(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'overlap_threshold' Input of this 'NonMaxSuppressionWithOverlaps' operation.
    pub fn overlap_threshold(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'score_threshold' Input of this 'NonMaxSuppressionWithOverlaps' operation.
    pub fn score_threshold(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
}
impl From<NonMaxSuppressionWithOverlapsInst> for crate::Operation {
    fn from(inst: NonMaxSuppressionWithOverlapsInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `NonMaxSuppressionWithOverlaps::new().build(overlaps, scores, max_output_size, overlap_threshold, score_threshold, scope)`.
pub fn non_max_suppression_with_overlaps<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
>(
    overlaps: O0,
    scores: O1,
    max_output_size: O2,
    overlap_threshold: O3,
    score_threshold: O4,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    NonMaxSuppressionWithOverlaps::new().build(
        overlaps,
        scores,
        max_output_size,
        overlap_threshold,
        score_threshold,
        scope,
    )
}

/// Builder for the `NonSerializableDataset` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct NonSerializableDataset {
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'NonSerializableDataset' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct NonSerializableDatasetInst {
    /// An instance of a fully built NonSerializableDataset Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl NonSerializableDataset {
    /// Creates a new `NonSerializableDataset`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `NonSerializableDataset` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input_dataset: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input_dataset.into(), scope)
    }
    fn build_impl(
        &self,
        input_dataset: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("NonSerializableDataset", |nd| {
            nd.add_input(input_dataset);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'NonSerializableDataset' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_dataset: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<NonSerializableDatasetInst> {
        let op = scope.new_operation("NonSerializableDataset", |builder| {
            builder.add_input(input_dataset);
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(NonSerializableDatasetInst { op })
    }
}
impl NonSerializableDatasetInst {
    /// Returns the 'handle' Output of this 'NonSerializableDataset' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_dataset' Input of this 'NonSerializableDataset' operation.
    pub fn input_dataset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<NonSerializableDatasetInst> for crate::Operation {
    fn from(inst: NonSerializableDatasetInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `NonSerializableDataset::new().build(input_dataset, scope)`.
pub fn non_serializable_dataset<O0: ::std::convert::Into<crate::Output>>(
    input_dataset: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    NonSerializableDataset::new().build(input_dataset, scope)
}

/// Builder for the `NotEqual` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct NotEqual {
    T: ::std::option::Option<crate::DataType>,
    incompatible_shape_error: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'NotEqual' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct NotEqualInst {
    /// An instance of a fully built NotEqual Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl NotEqual {
    /// Creates a new `NotEqual`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `incompatible_shape_error` attribute.
    pub fn incompatible_shape_error<ArgType: ::std::convert::Into<bool>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.incompatible_shape_error = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `NotEqual` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        x: O0,
        y: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), y.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        y: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("NotEqual", |nd| {
            nd.add_input(x);
            nd.add_input(y);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.incompatible_shape_error {
                nd.set_attr_bool("incompatible_shape_error", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'NotEqual' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        y: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<NotEqualInst> {
        let op = scope.new_operation("NotEqual", |builder| {
            builder.add_input(x);
            builder.add_input(y);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.incompatible_shape_error {
                builder.set_attr_bool("incompatible_shape_error", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(NotEqualInst { op })
    }
}
impl NotEqualInst {
    /// Returns the 'z' Output of this 'NotEqual' operation.
    pub fn z(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'NotEqual' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'y' Input of this 'NotEqual' operation.
    pub fn y(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<NotEqualInst> for crate::Operation {
    fn from(inst: NotEqualInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `NotEqual::new().build(x, y, scope)`.
pub fn not_equal<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    x: O0,
    y: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    NotEqual::new().build(x, y, scope)
}

/// Builder for the `NthElement` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct NthElement {
    reverse: ::std::option::Option<bool>,
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'NthElement' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct NthElementInst {
    /// An instance of a fully built NthElement Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl NthElement {
    /// Creates a new `NthElement`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `reverse` attribute.
    pub fn reverse<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.reverse = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `NthElement` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        n: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), n.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        n: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("NthElement", |nd| {
            nd.add_input(input);
            nd.add_input(n);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.reverse {
                nd.set_attr_bool("reverse", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'NthElement' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        n: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<NthElementInst> {
        let op = scope.new_operation("NthElement", |builder| {
            builder.add_input(input);
            builder.add_input(n);
            if let ::std::option::Option::Some(value) = &self.reverse {
                builder.set_attr_bool("reverse", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(NthElementInst { op })
    }
}
impl NthElementInst {
    /// Returns the 'values' Output of this 'NthElement' operation.
    pub fn values(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'NthElement' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'n' Input of this 'NthElement' operation.
    pub fn n(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<NthElementInst> for crate::Operation {
    fn from(inst: NthElementInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `NthElement::new().build(input, n, scope)`.
pub fn nth_element<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    input: O0,
    n: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    NthElement::new().build(input, n, scope)
}

/// Builder for the `OneHot` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct OneHot {
    axis: ::std::option::Option<i64>,
    T: ::std::option::Option<crate::DataType>,
    TI: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'OneHot' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct OneHotInst {
    /// An instance of a fully built OneHot Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl OneHot {
    /// Creates a new `OneHot`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `axis` attribute.
    pub fn axis<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.axis = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `TI` attribute.
    pub fn TI<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.TI = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `OneHot` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
    >(
        &self,
        indices: O0,
        depth: O1,
        on_value: O2,
        off_value: O3,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            indices.into(),
            depth.into(),
            on_value.into(),
            off_value.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        indices: crate::Output,
        depth: crate::Output,
        on_value: crate::Output,
        off_value: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("OneHot", |nd| {
            nd.add_input(indices);
            nd.add_input(depth);
            nd.add_input(on_value);
            nd.add_input(off_value);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.axis {
                nd.set_attr_int("axis", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.TI {
                nd.set_attr_type("TI", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'OneHot' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        indices: crate::Output,
        depth: crate::Output,
        on_value: crate::Output,
        off_value: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<OneHotInst> {
        let op = scope.new_operation("OneHot", |builder| {
            builder.add_input(indices);
            builder.add_input(depth);
            builder.add_input(on_value);
            builder.add_input(off_value);
            if let ::std::option::Option::Some(value) = &self.axis {
                builder.set_attr_int("axis", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.TI {
                builder.set_attr_type("TI", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(OneHotInst { op })
    }
}
impl OneHotInst {
    /// Returns the 'output' Output of this 'OneHot' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'indices' Input of this 'OneHot' operation.
    pub fn indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'depth' Input of this 'OneHot' operation.
    pub fn depth(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'on_value' Input of this 'OneHot' operation.
    pub fn on_value(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'off_value' Input of this 'OneHot' operation.
    pub fn off_value(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
}
impl From<OneHotInst> for crate::Operation {
    fn from(inst: OneHotInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `OneHot::new().build(indices, depth, on_value, off_value, scope)`.
pub fn one_hot<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
>(
    indices: O0,
    depth: O1,
    on_value: O2,
    off_value: O3,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    OneHot::new().build(indices, depth, on_value, off_value, scope)
}

/// Builder for the `OneShotIterator` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct OneShotIterator {
    dataset_factory: ::std::option::Option<::std::string::String>,
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    container: ::std::option::Option<::std::string::String>,
    shared_name: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'OneShotIterator' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct OneShotIteratorInst {
    /// An instance of a fully built OneShotIterator Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl OneShotIterator {
    /// Creates a new `OneShotIterator`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `dataset_factory` attribute.
    pub fn dataset_factory<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.dataset_factory = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `container` attribute.
    pub fn container<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.container = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shared_name` attribute.
    pub fn shared_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.shared_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `OneShotIterator` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("OneShotIterator", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.dataset_factory {
                nd.set_attr_string("dataset_factory", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.container {
                nd.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                nd.set_attr_string("shared_name", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'OneShotIterator' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(&self, scope: &mut crate::Scope) -> crate::Result<OneShotIteratorInst> {
        let op = scope.new_operation("OneShotIterator", |builder| {
            if let ::std::option::Option::Some(value) = &self.dataset_factory {
                builder.set_attr_string("dataset_factory", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.container {
                builder.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                builder.set_attr_string("shared_name", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(OneShotIteratorInst { op })
    }
}
impl OneShotIteratorInst {
    /// Returns the 'handle' Output of this 'OneShotIterator' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
}
impl From<OneShotIteratorInst> for crate::Operation {
    fn from(inst: OneShotIteratorInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `OneShotIterator::new().build(scope)`.
pub fn one_shot_iterator(scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
    OneShotIterator::new().build(scope)
}

/// Builder for the `OnesLike` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct OnesLike {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'OnesLike' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct OnesLikeInst {
    /// An instance of a fully built OnesLike Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl OnesLike {
    /// Creates a new `OnesLike`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `OnesLike` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        x: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("OnesLike", |nd| {
            nd.add_input(x);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'OnesLike' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<OnesLikeInst> {
        let op = scope.new_operation("OnesLike", |builder| {
            builder.add_input(x);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(OnesLikeInst { op })
    }
}
impl OnesLikeInst {
    /// Returns the 'y' Output of this 'OnesLike' operation.
    pub fn y(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'OnesLike' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<OnesLikeInst> for crate::Operation {
    fn from(inst: OnesLikeInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `OnesLike::new().build(x, scope)`.
pub fn ones_like<O0: ::std::convert::Into<crate::Output>>(
    x: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    OnesLike::new().build(x, scope)
}

/// Builder for the `OptimizeDataset` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct OptimizeDataset {
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    optimization_configs: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'OptimizeDataset' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct OptimizeDatasetInst {
    /// An instance of a fully built OptimizeDataset Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl OptimizeDataset {
    /// Creates a new `OptimizeDataset`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `optimization_configs` attribute.
    pub fn optimization_configs<
        ArgType: ::std::convert::Into<::std::vec::Vec<::std::string::String>>,
    >(
        mut self,
        value: ArgType,
    ) -> Self {
        self.optimization_configs = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `OptimizeDataset` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input_dataset: O0,
        optimizations: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input_dataset.into(), optimizations.into(), scope)
    }
    fn build_impl(
        &self,
        input_dataset: crate::Output,
        optimizations: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("OptimizeDataset", |nd| {
            nd.add_input(input_dataset);
            nd.add_input(optimizations);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.optimization_configs {
                nd.set_attr_string_list("optimization_configs", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'OptimizeDataset' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_dataset: crate::Output,
        optimizations: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<OptimizeDatasetInst> {
        let op = scope.new_operation("OptimizeDataset", |builder| {
            builder.add_input(input_dataset);
            builder.add_input(optimizations);
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.optimization_configs {
                builder.set_attr_string_list("optimization_configs", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(OptimizeDatasetInst { op })
    }
}
impl OptimizeDatasetInst {
    /// Returns the 'handle' Output of this 'OptimizeDataset' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_dataset' Input of this 'OptimizeDataset' operation.
    pub fn input_dataset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'optimizations' Input of this 'OptimizeDataset' operation.
    pub fn optimizations(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<OptimizeDatasetInst> for crate::Operation {
    fn from(inst: OptimizeDatasetInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `OptimizeDataset::new().build(input_dataset, optimizations, scope)`.
pub fn optimize_dataset<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    input_dataset: O0,
    optimizations: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    OptimizeDataset::new().build(input_dataset, optimizations, scope)
}

/// Builder for the `OptimizeDatasetV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct OptimizeDatasetV2 {
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    optimization_configs: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'OptimizeDatasetV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct OptimizeDatasetV2Inst {
    /// An instance of a fully built OptimizeDatasetV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl OptimizeDatasetV2 {
    /// Creates a new `OptimizeDatasetV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `optimization_configs` attribute.
    pub fn optimization_configs<
        ArgType: ::std::convert::Into<::std::vec::Vec<::std::string::String>>,
    >(
        mut self,
        value: ArgType,
    ) -> Self {
        self.optimization_configs = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `OptimizeDatasetV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input_dataset: O0,
        optimizations_enabled: O1,
        optimizations_disabled: O2,
        optimizations_default: O3,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            input_dataset.into(),
            optimizations_enabled.into(),
            optimizations_disabled.into(),
            optimizations_default.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        input_dataset: crate::Output,
        optimizations_enabled: crate::Output,
        optimizations_disabled: crate::Output,
        optimizations_default: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("OptimizeDatasetV2", |nd| {
            nd.add_input(input_dataset);
            nd.add_input(optimizations_enabled);
            nd.add_input(optimizations_disabled);
            nd.add_input(optimizations_default);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.optimization_configs {
                nd.set_attr_string_list("optimization_configs", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'OptimizeDatasetV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_dataset: crate::Output,
        optimizations_enabled: crate::Output,
        optimizations_disabled: crate::Output,
        optimizations_default: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<OptimizeDatasetV2Inst> {
        let op = scope.new_operation("OptimizeDatasetV2", |builder| {
            builder.add_input(input_dataset);
            builder.add_input(optimizations_enabled);
            builder.add_input(optimizations_disabled);
            builder.add_input(optimizations_default);
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.optimization_configs {
                builder.set_attr_string_list("optimization_configs", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(OptimizeDatasetV2Inst { op })
    }
}
impl OptimizeDatasetV2Inst {
    /// Returns the 'handle' Output of this 'OptimizeDatasetV2' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_dataset' Input of this 'OptimizeDatasetV2' operation.
    pub fn input_dataset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'optimizations_enabled' Input of this 'OptimizeDatasetV2' operation.
    pub fn optimizations_enabled(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'optimizations_disabled' Input of this 'OptimizeDatasetV2' operation.
    pub fn optimizations_disabled(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'optimizations_default' Input of this 'OptimizeDatasetV2' operation.
    pub fn optimizations_default(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
}
impl From<OptimizeDatasetV2Inst> for crate::Operation {
    fn from(inst: OptimizeDatasetV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `OptimizeDatasetV2::new().build(input_dataset, optimizations_enabled, optimizations_disabled, optimizations_default, scope)`.
pub fn optimize_dataset_v2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
>(
    input_dataset: O0,
    optimizations_enabled: O1,
    optimizations_disabled: O2,
    optimizations_default: O3,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    OptimizeDatasetV2::new().build(
        input_dataset,
        optimizations_enabled,
        optimizations_disabled,
        optimizations_default,
        scope,
    )
}

/// Builder for the `OptionalFromValue` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct OptionalFromValue {
    Toutput_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'OptionalFromValue' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct OptionalFromValueInst {
    /// An instance of a fully built OptionalFromValue Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl OptionalFromValue {
    /// Creates a new `OptionalFromValue`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `Toutput_types` attribute.
    pub fn Toutput_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Toutput_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `OptionalFromValue` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        components: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(components.into(), scope)
    }
    fn build_impl(
        &self,
        components: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("OptionalFromValue", |nd| {
            nd.add_input(components);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.Toutput_types {
                nd.set_attr_type_list("Toutput_types", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'OptionalFromValue' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        components: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<OptionalFromValueInst> {
        let op = scope.new_operation("OptionalFromValue", |builder| {
            builder.add_input(components);
            if let ::std::option::Option::Some(value) = &self.Toutput_types {
                builder.set_attr_type_list("Toutput_types", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(OptionalFromValueInst { op })
    }
}
impl OptionalFromValueInst {
    /// Returns the 'optional' Output of this 'OptionalFromValue' operation.
    pub fn optional(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'components' Input of this 'OptionalFromValue' operation.
    pub fn components(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<OptionalFromValueInst> for crate::Operation {
    fn from(inst: OptionalFromValueInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `OptionalFromValue::new().build(components, scope)`.
pub fn optional_from_value<O0: ::std::convert::Into<crate::Output>>(
    components: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    OptionalFromValue::new().build(components, scope)
}

/// Builder for the `OptionalGetValue` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct OptionalGetValue {
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'OptionalGetValue' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct OptionalGetValueInst {
    /// An instance of a fully built OptionalGetValue Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl OptionalGetValue {
    /// Creates a new `OptionalGetValue`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `OptionalGetValue` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        optional: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(optional.into(), scope)
    }
    fn build_impl(
        &self,
        optional: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("OptionalGetValue", |nd| {
            nd.add_input(optional);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'OptionalGetValue' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        optional: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<OptionalGetValueInst> {
        let op = scope.new_operation("OptionalGetValue", |builder| {
            builder.add_input(optional);
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(OptionalGetValueInst { op })
    }
}
impl OptionalGetValueInst {
    /// Returns the 'components' Output of this 'OptionalGetValue' operation.
    pub fn components(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'optional' Input of this 'OptionalGetValue' operation.
    pub fn optional(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<OptionalGetValueInst> for crate::Operation {
    fn from(inst: OptionalGetValueInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `OptionalGetValue::new().build(optional, scope)`.
pub fn optional_get_value<O0: ::std::convert::Into<crate::Output>>(
    optional: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    OptionalGetValue::new().build(optional, scope)
}

/// Builder for the `OptionalHasValue` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct OptionalHasValue {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'OptionalHasValue' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct OptionalHasValueInst {
    /// An instance of a fully built OptionalHasValue Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl OptionalHasValue {
    /// Creates a new `OptionalHasValue`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `OptionalHasValue` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        optional: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(optional.into(), scope)
    }
    fn build_impl(
        &self,
        optional: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("OptionalHasValue", |nd| {
            nd.add_input(optional);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'OptionalHasValue' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        optional: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<OptionalHasValueInst> {
        let op = scope.new_operation("OptionalHasValue", |builder| {
            builder.add_input(optional);
            ::std::result::Result::Ok(())
        })?;
        Ok(OptionalHasValueInst { op })
    }
}
impl OptionalHasValueInst {
    /// Returns the 'has_value' Output of this 'OptionalHasValue' operation.
    pub fn has_value(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'optional' Input of this 'OptionalHasValue' operation.
    pub fn optional(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<OptionalHasValueInst> for crate::Operation {
    fn from(inst: OptionalHasValueInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `OptionalHasValue::new().build(optional, scope)`.
pub fn optional_has_value<O0: ::std::convert::Into<crate::Output>>(
    optional: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    OptionalHasValue::new().build(optional, scope)
}

/// Builder for the `OptionalNone` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct OptionalNone {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'OptionalNone' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct OptionalNoneInst {
    /// An instance of a fully built OptionalNone Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl OptionalNone {
    /// Creates a new `OptionalNone`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `OptionalNone` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("OptionalNone", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'OptionalNone' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(&self, scope: &mut crate::Scope) -> crate::Result<OptionalNoneInst> {
        let op = scope.new_operation("OptionalNone", |builder| ::std::result::Result::Ok(()))?;
        Ok(OptionalNoneInst { op })
    }
}
impl OptionalNoneInst {
    /// Returns the 'optional' Output of this 'OptionalNone' operation.
    pub fn optional(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
}
impl From<OptionalNoneInst> for crate::Operation {
    fn from(inst: OptionalNoneInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `OptionalNone::new().build(scope)`.
pub fn optional_none(scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
    OptionalNone::new().build(scope)
}

/// Builder for the `OptionsDataset` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct OptionsDataset {
    serialized_options: ::std::option::Option<::std::string::String>,
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    metadata: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'OptionsDataset' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct OptionsDatasetInst {
    /// An instance of a fully built OptionsDataset Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl OptionsDataset {
    /// Creates a new `OptionsDataset`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `serialized_options` attribute.
    pub fn serialized_options<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.serialized_options = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `metadata` attribute.
    pub fn metadata<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.metadata = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `OptionsDataset` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input_dataset: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input_dataset.into(), scope)
    }
    fn build_impl(
        &self,
        input_dataset: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("OptionsDataset", |nd| {
            nd.add_input(input_dataset);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.serialized_options {
                nd.set_attr_string("serialized_options", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.metadata {
                nd.set_attr_string("metadata", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'OptionsDataset' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_dataset: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<OptionsDatasetInst> {
        let op = scope.new_operation("OptionsDataset", |builder| {
            builder.add_input(input_dataset);
            if let ::std::option::Option::Some(value) = &self.serialized_options {
                builder.set_attr_string("serialized_options", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.metadata {
                builder.set_attr_string("metadata", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(OptionsDatasetInst { op })
    }
}
impl OptionsDatasetInst {
    /// Returns the 'handle' Output of this 'OptionsDataset' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_dataset' Input of this 'OptionsDataset' operation.
    pub fn input_dataset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<OptionsDatasetInst> for crate::Operation {
    fn from(inst: OptionsDatasetInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `OptionsDataset::new().build(input_dataset, scope)`.
pub fn options_dataset<O0: ::std::convert::Into<crate::Output>>(
    input_dataset: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    OptionsDataset::new().build(input_dataset, scope)
}

/// Builder for the `OrderedMapClear` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct OrderedMapClear {
    capacity: ::std::option::Option<i64>,
    memory_limit: ::std::option::Option<i64>,
    dtypes: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    container: ::std::option::Option<::std::string::String>,
    shared_name: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'OrderedMapClear' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct OrderedMapClearInst {
    /// An instance of a fully built OrderedMapClear Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl OrderedMapClear {
    /// Creates a new `OrderedMapClear`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `capacity` attribute.
    pub fn capacity<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.capacity = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `memory_limit` attribute.
    pub fn memory_limit<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.memory_limit = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `dtypes` attribute.
    pub fn dtypes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.dtypes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `container` attribute.
    pub fn container<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.container = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shared_name` attribute.
    pub fn shared_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.shared_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `OrderedMapClear` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("OrderedMapClear", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.capacity {
                nd.set_attr_int("capacity", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.memory_limit {
                nd.set_attr_int("memory_limit", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dtypes {
                nd.set_attr_type_list("dtypes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.container {
                nd.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                nd.set_attr_string("shared_name", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'OrderedMapClear' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(&self, scope: &mut crate::Scope) -> crate::Result<OrderedMapClearInst> {
        let op = scope.new_operation("OrderedMapClear", |builder| {
            if let ::std::option::Option::Some(value) = &self.capacity {
                builder.set_attr_int("capacity", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.memory_limit {
                builder.set_attr_int("memory_limit", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dtypes {
                builder.set_attr_type_list("dtypes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.container {
                builder.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                builder.set_attr_string("shared_name", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(OrderedMapClearInst { op })
    }
}
impl OrderedMapClearInst {}
impl From<OrderedMapClearInst> for crate::Operation {
    fn from(inst: OrderedMapClearInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `OrderedMapClear::new().build(scope)`.
pub fn ordered_map_clear(scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
    OrderedMapClear::new().build(scope)
}

/// Builder for the `OrderedMapIncompleteSize` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct OrderedMapIncompleteSize {
    capacity: ::std::option::Option<i64>,
    memory_limit: ::std::option::Option<i64>,
    dtypes: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    container: ::std::option::Option<::std::string::String>,
    shared_name: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'OrderedMapIncompleteSize' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct OrderedMapIncompleteSizeInst {
    /// An instance of a fully built OrderedMapIncompleteSize Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl OrderedMapIncompleteSize {
    /// Creates a new `OrderedMapIncompleteSize`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `capacity` attribute.
    pub fn capacity<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.capacity = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `memory_limit` attribute.
    pub fn memory_limit<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.memory_limit = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `dtypes` attribute.
    pub fn dtypes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.dtypes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `container` attribute.
    pub fn container<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.container = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shared_name` attribute.
    pub fn shared_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.shared_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `OrderedMapIncompleteSize` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("OrderedMapIncompleteSize", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.capacity {
                nd.set_attr_int("capacity", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.memory_limit {
                nd.set_attr_int("memory_limit", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dtypes {
                nd.set_attr_type_list("dtypes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.container {
                nd.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                nd.set_attr_string("shared_name", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'OrderedMapIncompleteSize' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        scope: &mut crate::Scope,
    ) -> crate::Result<OrderedMapIncompleteSizeInst> {
        let op = scope.new_operation("OrderedMapIncompleteSize", |builder| {
            if let ::std::option::Option::Some(value) = &self.capacity {
                builder.set_attr_int("capacity", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.memory_limit {
                builder.set_attr_int("memory_limit", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dtypes {
                builder.set_attr_type_list("dtypes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.container {
                builder.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                builder.set_attr_string("shared_name", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(OrderedMapIncompleteSizeInst { op })
    }
}
impl OrderedMapIncompleteSizeInst {
    /// Returns the 'size' Output of this 'OrderedMapIncompleteSize' operation.
    pub fn size(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
}
impl From<OrderedMapIncompleteSizeInst> for crate::Operation {
    fn from(inst: OrderedMapIncompleteSizeInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `OrderedMapIncompleteSize::new().build(scope)`.
pub fn ordered_map_incomplete_size(scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
    OrderedMapIncompleteSize::new().build(scope)
}

/// Builder for the `OrderedMapPeek` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct OrderedMapPeek {
    capacity: ::std::option::Option<i64>,
    memory_limit: ::std::option::Option<i64>,
    dtypes: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    container: ::std::option::Option<::std::string::String>,
    shared_name: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'OrderedMapPeek' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct OrderedMapPeekInst {
    /// An instance of a fully built OrderedMapPeek Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl OrderedMapPeek {
    /// Creates a new `OrderedMapPeek`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `capacity` attribute.
    pub fn capacity<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.capacity = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `memory_limit` attribute.
    pub fn memory_limit<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.memory_limit = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `dtypes` attribute.
    pub fn dtypes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.dtypes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `container` attribute.
    pub fn container<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.container = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shared_name` attribute.
    pub fn shared_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.shared_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `OrderedMapPeek` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        key: O0,
        indices: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(key.into(), indices.into(), scope)
    }
    fn build_impl(
        &self,
        key: crate::Output,
        indices: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("OrderedMapPeek", |nd| {
            nd.add_input(key);
            nd.add_input(indices);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.capacity {
                nd.set_attr_int("capacity", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.memory_limit {
                nd.set_attr_int("memory_limit", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dtypes {
                nd.set_attr_type_list("dtypes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.container {
                nd.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                nd.set_attr_string("shared_name", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'OrderedMapPeek' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        key: crate::Output,
        indices: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<OrderedMapPeekInst> {
        let op = scope.new_operation("OrderedMapPeek", |builder| {
            builder.add_input(key);
            builder.add_input(indices);
            if let ::std::option::Option::Some(value) = &self.capacity {
                builder.set_attr_int("capacity", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.memory_limit {
                builder.set_attr_int("memory_limit", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dtypes {
                builder.set_attr_type_list("dtypes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.container {
                builder.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                builder.set_attr_string("shared_name", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(OrderedMapPeekInst { op })
    }
}
impl OrderedMapPeekInst {
    /// Returns the 'values' Output of this 'OrderedMapPeek' operation.
    pub fn values(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'key' Input of this 'OrderedMapPeek' operation.
    pub fn key(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'indices' Input of this 'OrderedMapPeek' operation.
    pub fn indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<OrderedMapPeekInst> for crate::Operation {
    fn from(inst: OrderedMapPeekInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `OrderedMapPeek::new().build(key, indices, scope)`.
pub fn ordered_map_peek<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    key: O0,
    indices: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    OrderedMapPeek::new().build(key, indices, scope)
}

/// Builder for the `OrderedMapSize` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct OrderedMapSize {
    capacity: ::std::option::Option<i64>,
    memory_limit: ::std::option::Option<i64>,
    dtypes: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    container: ::std::option::Option<::std::string::String>,
    shared_name: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'OrderedMapSize' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct OrderedMapSizeInst {
    /// An instance of a fully built OrderedMapSize Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl OrderedMapSize {
    /// Creates a new `OrderedMapSize`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `capacity` attribute.
    pub fn capacity<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.capacity = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `memory_limit` attribute.
    pub fn memory_limit<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.memory_limit = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `dtypes` attribute.
    pub fn dtypes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.dtypes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `container` attribute.
    pub fn container<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.container = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shared_name` attribute.
    pub fn shared_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.shared_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `OrderedMapSize` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("OrderedMapSize", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.capacity {
                nd.set_attr_int("capacity", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.memory_limit {
                nd.set_attr_int("memory_limit", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dtypes {
                nd.set_attr_type_list("dtypes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.container {
                nd.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                nd.set_attr_string("shared_name", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'OrderedMapSize' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(&self, scope: &mut crate::Scope) -> crate::Result<OrderedMapSizeInst> {
        let op = scope.new_operation("OrderedMapSize", |builder| {
            if let ::std::option::Option::Some(value) = &self.capacity {
                builder.set_attr_int("capacity", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.memory_limit {
                builder.set_attr_int("memory_limit", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dtypes {
                builder.set_attr_type_list("dtypes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.container {
                builder.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                builder.set_attr_string("shared_name", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(OrderedMapSizeInst { op })
    }
}
impl OrderedMapSizeInst {
    /// Returns the 'size' Output of this 'OrderedMapSize' operation.
    pub fn size(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
}
impl From<OrderedMapSizeInst> for crate::Operation {
    fn from(inst: OrderedMapSizeInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `OrderedMapSize::new().build(scope)`.
pub fn ordered_map_size(scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
    OrderedMapSize::new().build(scope)
}

/// Builder for the `OrderedMapStage` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct OrderedMapStage {
    capacity: ::std::option::Option<i64>,
    memory_limit: ::std::option::Option<i64>,
    dtypes: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    fake_dtypes: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    container: ::std::option::Option<::std::string::String>,
    shared_name: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'OrderedMapStage' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct OrderedMapStageInst {
    /// An instance of a fully built OrderedMapStage Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl OrderedMapStage {
    /// Creates a new `OrderedMapStage`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `capacity` attribute.
    pub fn capacity<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.capacity = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `memory_limit` attribute.
    pub fn memory_limit<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.memory_limit = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `dtypes` attribute.
    pub fn dtypes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.dtypes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `fake_dtypes` attribute.
    pub fn fake_dtypes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.fake_dtypes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `container` attribute.
    pub fn container<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.container = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shared_name` attribute.
    pub fn shared_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.shared_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `OrderedMapStage` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        key: O0,
        indices: O1,
        values: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(key.into(), indices.into(), values.into(), scope)
    }
    fn build_impl(
        &self,
        key: crate::Output,
        indices: crate::Output,
        values: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("OrderedMapStage", |nd| {
            nd.add_input(key);
            nd.add_input(indices);
            nd.add_input(values);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.capacity {
                nd.set_attr_int("capacity", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.memory_limit {
                nd.set_attr_int("memory_limit", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dtypes {
                nd.set_attr_type_list("dtypes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.fake_dtypes {
                nd.set_attr_type_list("fake_dtypes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.container {
                nd.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                nd.set_attr_string("shared_name", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'OrderedMapStage' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        key: crate::Output,
        indices: crate::Output,
        values: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<OrderedMapStageInst> {
        let op = scope.new_operation("OrderedMapStage", |builder| {
            builder.add_input(key);
            builder.add_input(indices);
            builder.add_input(values);
            if let ::std::option::Option::Some(value) = &self.capacity {
                builder.set_attr_int("capacity", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.memory_limit {
                builder.set_attr_int("memory_limit", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dtypes {
                builder.set_attr_type_list("dtypes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.fake_dtypes {
                builder.set_attr_type_list("fake_dtypes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.container {
                builder.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                builder.set_attr_string("shared_name", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(OrderedMapStageInst { op })
    }
}
impl OrderedMapStageInst {
    /// Returns the 'key' Input of this 'OrderedMapStage' operation.
    pub fn key(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'indices' Input of this 'OrderedMapStage' operation.
    pub fn indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'values' Input of this 'OrderedMapStage' operation.
    pub fn values(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<OrderedMapStageInst> for crate::Operation {
    fn from(inst: OrderedMapStageInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `OrderedMapStage::new().build(key, indices, values, scope)`.
pub fn ordered_map_stage<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    key: O0,
    indices: O1,
    values: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    OrderedMapStage::new().build(key, indices, values, scope)
}

/// Builder for the `OrderedMapUnstage` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct OrderedMapUnstage {
    capacity: ::std::option::Option<i64>,
    memory_limit: ::std::option::Option<i64>,
    dtypes: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    container: ::std::option::Option<::std::string::String>,
    shared_name: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'OrderedMapUnstage' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct OrderedMapUnstageInst {
    /// An instance of a fully built OrderedMapUnstage Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl OrderedMapUnstage {
    /// Creates a new `OrderedMapUnstage`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `capacity` attribute.
    pub fn capacity<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.capacity = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `memory_limit` attribute.
    pub fn memory_limit<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.memory_limit = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `dtypes` attribute.
    pub fn dtypes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.dtypes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `container` attribute.
    pub fn container<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.container = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shared_name` attribute.
    pub fn shared_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.shared_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `OrderedMapUnstage` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        key: O0,
        indices: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(key.into(), indices.into(), scope)
    }
    fn build_impl(
        &self,
        key: crate::Output,
        indices: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("OrderedMapUnstage", |nd| {
            nd.add_input(key);
            nd.add_input(indices);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.capacity {
                nd.set_attr_int("capacity", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.memory_limit {
                nd.set_attr_int("memory_limit", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dtypes {
                nd.set_attr_type_list("dtypes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.container {
                nd.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                nd.set_attr_string("shared_name", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'OrderedMapUnstage' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        key: crate::Output,
        indices: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<OrderedMapUnstageInst> {
        let op = scope.new_operation("OrderedMapUnstage", |builder| {
            builder.add_input(key);
            builder.add_input(indices);
            if let ::std::option::Option::Some(value) = &self.capacity {
                builder.set_attr_int("capacity", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.memory_limit {
                builder.set_attr_int("memory_limit", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dtypes {
                builder.set_attr_type_list("dtypes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.container {
                builder.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                builder.set_attr_string("shared_name", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(OrderedMapUnstageInst { op })
    }
}
impl OrderedMapUnstageInst {
    /// Returns the 'values' Output of this 'OrderedMapUnstage' operation.
    pub fn values(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'key' Input of this 'OrderedMapUnstage' operation.
    pub fn key(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'indices' Input of this 'OrderedMapUnstage' operation.
    pub fn indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<OrderedMapUnstageInst> for crate::Operation {
    fn from(inst: OrderedMapUnstageInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `OrderedMapUnstage::new().build(key, indices, scope)`.
pub fn ordered_map_unstage<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    key: O0,
    indices: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    OrderedMapUnstage::new().build(key, indices, scope)
}

/// Builder for the `OrderedMapUnstageNoKey` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct OrderedMapUnstageNoKey {
    capacity: ::std::option::Option<i64>,
    memory_limit: ::std::option::Option<i64>,
    dtypes: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    container: ::std::option::Option<::std::string::String>,
    shared_name: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'OrderedMapUnstageNoKey' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct OrderedMapUnstageNoKeyInst {
    /// An instance of a fully built OrderedMapUnstageNoKey Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl OrderedMapUnstageNoKey {
    /// Creates a new `OrderedMapUnstageNoKey`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `capacity` attribute.
    pub fn capacity<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.capacity = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `memory_limit` attribute.
    pub fn memory_limit<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.memory_limit = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `dtypes` attribute.
    pub fn dtypes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.dtypes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `container` attribute.
    pub fn container<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.container = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shared_name` attribute.
    pub fn shared_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.shared_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `OrderedMapUnstageNoKey` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        indices: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(indices.into(), scope)
    }
    fn build_impl(
        &self,
        indices: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("OrderedMapUnstageNoKey", |nd| {
            nd.add_input(indices);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.capacity {
                nd.set_attr_int("capacity", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.memory_limit {
                nd.set_attr_int("memory_limit", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dtypes {
                nd.set_attr_type_list("dtypes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.container {
                nd.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                nd.set_attr_string("shared_name", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'OrderedMapUnstageNoKey' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        indices: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<OrderedMapUnstageNoKeyInst> {
        let op = scope.new_operation("OrderedMapUnstageNoKey", |builder| {
            builder.add_input(indices);
            if let ::std::option::Option::Some(value) = &self.capacity {
                builder.set_attr_int("capacity", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.memory_limit {
                builder.set_attr_int("memory_limit", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dtypes {
                builder.set_attr_type_list("dtypes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.container {
                builder.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                builder.set_attr_string("shared_name", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(OrderedMapUnstageNoKeyInst { op })
    }
}
impl OrderedMapUnstageNoKeyInst {
    /// Returns the 'key' Output of this 'OrderedMapUnstageNoKey' operation.
    pub fn key(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'values' Output of this 'OrderedMapUnstageNoKey' operation.
    pub fn values(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'indices' Input of this 'OrderedMapUnstageNoKey' operation.
    pub fn indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<OrderedMapUnstageNoKeyInst> for crate::Operation {
    fn from(inst: OrderedMapUnstageNoKeyInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `OrderedMapUnstageNoKey::new().build(indices, scope)`.
pub fn ordered_map_unstage_no_key<O0: ::std::convert::Into<crate::Output>>(
    indices: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    OrderedMapUnstageNoKey::new().build(indices, scope)
}

/// Builder for the `OutfeedDequeue` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct OutfeedDequeue {
    dtype: ::std::option::Option<crate::DataType>,
    shape: ::std::option::Option<crate::Shape>,
    device_ordinal: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'OutfeedDequeue' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct OutfeedDequeueInst {
    /// An instance of a fully built OutfeedDequeue Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl OutfeedDequeue {
    /// Creates a new `OutfeedDequeue`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `dtype` attribute.
    pub fn dtype<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shape` attribute.
    pub fn shape<ArgType: ::std::convert::Into<crate::Shape>>(mut self, value: ArgType) -> Self {
        self.shape = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `device_ordinal` attribute.
    pub fn device_ordinal<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.device_ordinal = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `OutfeedDequeue` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("OutfeedDequeue", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                nd.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shape {
                nd.set_attr_shape("shape", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.device_ordinal {
                nd.set_attr_int("device_ordinal", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'OutfeedDequeue' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(&self, scope: &mut crate::Scope) -> crate::Result<OutfeedDequeueInst> {
        let op = scope.new_operation("OutfeedDequeue", |builder| {
            if let ::std::option::Option::Some(value) = &self.dtype {
                builder.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shape {
                builder.set_attr_shape("shape", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.device_ordinal {
                builder.set_attr_int("device_ordinal", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(OutfeedDequeueInst { op })
    }
}
impl OutfeedDequeueInst {
    /// Returns the 'output' Output of this 'OutfeedDequeue' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
}
impl From<OutfeedDequeueInst> for crate::Operation {
    fn from(inst: OutfeedDequeueInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `OutfeedDequeue::new().build(scope)`.
pub fn outfeed_dequeue(scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
    OutfeedDequeue::new().build(scope)
}

/// Builder for the `OutfeedDequeueTuple` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct OutfeedDequeueTuple {
    dtypes: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    device_ordinal: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'OutfeedDequeueTuple' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct OutfeedDequeueTupleInst {
    /// An instance of a fully built OutfeedDequeueTuple Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl OutfeedDequeueTuple {
    /// Creates a new `OutfeedDequeueTuple`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `dtypes` attribute.
    pub fn dtypes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.dtypes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shapes` attribute.
    pub fn shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `device_ordinal` attribute.
    pub fn device_ordinal<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.device_ordinal = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `OutfeedDequeueTuple` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("OutfeedDequeueTuple", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.dtypes {
                nd.set_attr_type_list("dtypes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shapes {
                nd.set_attr_shape_list("shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.device_ordinal {
                nd.set_attr_int("device_ordinal", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'OutfeedDequeueTuple' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        scope: &mut crate::Scope,
    ) -> crate::Result<OutfeedDequeueTupleInst> {
        let op = scope.new_operation("OutfeedDequeueTuple", |builder| {
            if let ::std::option::Option::Some(value) = &self.dtypes {
                builder.set_attr_type_list("dtypes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shapes {
                builder.set_attr_shape_list("shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.device_ordinal {
                builder.set_attr_int("device_ordinal", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(OutfeedDequeueTupleInst { op })
    }
}
impl OutfeedDequeueTupleInst {
    /// Returns the 'outputs' Output of this 'OutfeedDequeueTuple' operation.
    pub fn outputs(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
}
impl From<OutfeedDequeueTupleInst> for crate::Operation {
    fn from(inst: OutfeedDequeueTupleInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `OutfeedDequeueTuple::new().build(scope)`.
pub fn outfeed_dequeue_tuple(scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
    OutfeedDequeueTuple::new().build(scope)
}

/// Builder for the `OutfeedDequeueTupleV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct OutfeedDequeueTupleV2 {
    dtypes: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'OutfeedDequeueTupleV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct OutfeedDequeueTupleV2Inst {
    /// An instance of a fully built OutfeedDequeueTupleV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl OutfeedDequeueTupleV2 {
    /// Creates a new `OutfeedDequeueTupleV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `dtypes` attribute.
    pub fn dtypes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.dtypes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shapes` attribute.
    pub fn shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `OutfeedDequeueTupleV2` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        device_ordinal: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(device_ordinal.into(), scope)
    }
    fn build_impl(
        &self,
        device_ordinal: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("OutfeedDequeueTupleV2", |nd| {
            nd.add_input(device_ordinal);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.dtypes {
                nd.set_attr_type_list("dtypes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shapes {
                nd.set_attr_shape_list("shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'OutfeedDequeueTupleV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        device_ordinal: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<OutfeedDequeueTupleV2Inst> {
        let op = scope.new_operation("OutfeedDequeueTupleV2", |builder| {
            builder.add_input(device_ordinal);
            if let ::std::option::Option::Some(value) = &self.dtypes {
                builder.set_attr_type_list("dtypes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shapes {
                builder.set_attr_shape_list("shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(OutfeedDequeueTupleV2Inst { op })
    }
}
impl OutfeedDequeueTupleV2Inst {
    /// Returns the 'outputs' Output of this 'OutfeedDequeueTupleV2' operation.
    pub fn outputs(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'device_ordinal' Input of this 'OutfeedDequeueTupleV2' operation.
    pub fn device_ordinal(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<OutfeedDequeueTupleV2Inst> for crate::Operation {
    fn from(inst: OutfeedDequeueTupleV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `OutfeedDequeueTupleV2::new().build(device_ordinal, scope)`.
pub fn outfeed_dequeue_tuple_v2<O0: ::std::convert::Into<crate::Output>>(
    device_ordinal: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    OutfeedDequeueTupleV2::new().build(device_ordinal, scope)
}

/// Builder for the `OutfeedDequeueV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct OutfeedDequeueV2 {
    dtype: ::std::option::Option<crate::DataType>,
    shape: ::std::option::Option<crate::Shape>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'OutfeedDequeueV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct OutfeedDequeueV2Inst {
    /// An instance of a fully built OutfeedDequeueV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl OutfeedDequeueV2 {
    /// Creates a new `OutfeedDequeueV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `dtype` attribute.
    pub fn dtype<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shape` attribute.
    pub fn shape<ArgType: ::std::convert::Into<crate::Shape>>(mut self, value: ArgType) -> Self {
        self.shape = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `OutfeedDequeueV2` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        device_ordinal: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(device_ordinal.into(), scope)
    }
    fn build_impl(
        &self,
        device_ordinal: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("OutfeedDequeueV2", |nd| {
            nd.add_input(device_ordinal);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                nd.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shape {
                nd.set_attr_shape("shape", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'OutfeedDequeueV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        device_ordinal: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<OutfeedDequeueV2Inst> {
        let op = scope.new_operation("OutfeedDequeueV2", |builder| {
            builder.add_input(device_ordinal);
            if let ::std::option::Option::Some(value) = &self.dtype {
                builder.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shape {
                builder.set_attr_shape("shape", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(OutfeedDequeueV2Inst { op })
    }
}
impl OutfeedDequeueV2Inst {
    /// Returns the 'output' Output of this 'OutfeedDequeueV2' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'device_ordinal' Input of this 'OutfeedDequeueV2' operation.
    pub fn device_ordinal(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<OutfeedDequeueV2Inst> for crate::Operation {
    fn from(inst: OutfeedDequeueV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `OutfeedDequeueV2::new().build(device_ordinal, scope)`.
pub fn outfeed_dequeue_v2<O0: ::std::convert::Into<crate::Output>>(
    device_ordinal: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    OutfeedDequeueV2::new().build(device_ordinal, scope)
}

/// Builder for the `OutfeedEnqueue` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct OutfeedEnqueue {
    dtype: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'OutfeedEnqueue' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct OutfeedEnqueueInst {
    /// An instance of a fully built OutfeedEnqueue Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl OutfeedEnqueue {
    /// Creates a new `OutfeedEnqueue`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `dtype` attribute.
    pub fn dtype<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `OutfeedEnqueue` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("OutfeedEnqueue", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                nd.set_attr_type("dtype", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'OutfeedEnqueue' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<OutfeedEnqueueInst> {
        let op = scope.new_operation("OutfeedEnqueue", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.dtype {
                builder.set_attr_type("dtype", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(OutfeedEnqueueInst { op })
    }
}
impl OutfeedEnqueueInst {
    /// Returns the 'input' Input of this 'OutfeedEnqueue' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<OutfeedEnqueueInst> for crate::Operation {
    fn from(inst: OutfeedEnqueueInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `OutfeedEnqueue::new().build(input, scope)`.
pub fn outfeed_enqueue<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    OutfeedEnqueue::new().build(input, scope)
}

/// Builder for the `OutfeedEnqueueTuple` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct OutfeedEnqueueTuple {
    dtypes: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'OutfeedEnqueueTuple' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct OutfeedEnqueueTupleInst {
    /// An instance of a fully built OutfeedEnqueueTuple Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl OutfeedEnqueueTuple {
    /// Creates a new `OutfeedEnqueueTuple`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `dtypes` attribute.
    pub fn dtypes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.dtypes = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `OutfeedEnqueueTuple` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        inputs: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(inputs.into(), scope)
    }
    fn build_impl(
        &self,
        inputs: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("OutfeedEnqueueTuple", |nd| {
            nd.add_input(inputs);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.dtypes {
                nd.set_attr_type_list("dtypes", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'OutfeedEnqueueTuple' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        inputs: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<OutfeedEnqueueTupleInst> {
        let op = scope.new_operation("OutfeedEnqueueTuple", |builder| {
            builder.add_input(inputs);
            if let ::std::option::Option::Some(value) = &self.dtypes {
                builder.set_attr_type_list("dtypes", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(OutfeedEnqueueTupleInst { op })
    }
}
impl OutfeedEnqueueTupleInst {
    /// Returns the 'inputs' Input of this 'OutfeedEnqueueTuple' operation.
    pub fn inputs(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<OutfeedEnqueueTupleInst> for crate::Operation {
    fn from(inst: OutfeedEnqueueTupleInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `OutfeedEnqueueTuple::new().build(inputs, scope)`.
pub fn outfeed_enqueue_tuple<O0: ::std::convert::Into<crate::Output>>(
    inputs: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    OutfeedEnqueueTuple::new().build(inputs, scope)
}

/// Builder for the `Pack` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Pack {
    N: ::std::option::Option<i64>,
    T: ::std::option::Option<crate::DataType>,
    axis: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Pack' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct PackInst {
    /// An instance of a fully built Pack Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Pack {
    /// Creates a new `Pack`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `N` attribute.
    pub fn N<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.N = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `axis` attribute.
    pub fn axis<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.axis = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Pack` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        values: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(values.into(), scope)
    }
    fn build_impl(
        &self,
        values: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Pack", |nd| {
            nd.add_input(values);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.N {
                nd.set_attr_int("N", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.axis {
                nd.set_attr_int("axis", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Pack' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        values: Vec<crate::Output>,
        scope: &mut crate::Scope,
    ) -> crate::Result<PackInst> {
        let op = scope.new_operation("Pack", |builder| {
            builder.add_input_list(&values);
            builder.set_attr_int("N", values.clone().len() as i64)?;
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.axis {
                builder.set_attr_int("axis", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(PackInst { op })
    }
}
impl PackInst {
    /// Returns the 'output' Output of this 'Pack' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns a Vector of values for 'values' Input of this Pack operation.
    pub fn values(&self) -> crate::Result<Vec<crate::Input>> {
        let mut Inputs = vec![];
        for i in 0..self.op.get_attr_int("N")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
}
impl From<PackInst> for crate::Operation {
    fn from(inst: PackInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Pack::new().build(values, scope)`.
pub fn pack<O0: ::std::convert::Into<crate::Output>>(
    values: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Pack::new().build(values, scope)
}

/// Builder for the `Pad` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Pad {
    T: ::std::option::Option<crate::DataType>,
    Tpaddings: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Pad' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct PadInst {
    /// An instance of a fully built Pad Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Pad {
    /// Creates a new `Pad`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tpaddings` attribute.
    pub fn Tpaddings<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tpaddings = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Pad` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        paddings: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), paddings.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        paddings: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Pad", |nd| {
            nd.add_input(input);
            nd.add_input(paddings);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tpaddings {
                nd.set_attr_type("Tpaddings", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Pad' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        paddings: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<PadInst> {
        let op = scope.new_operation("Pad", |builder| {
            builder.add_input(input);
            builder.add_input(paddings);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tpaddings {
                builder.set_attr_type("Tpaddings", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(PadInst { op })
    }
}
impl PadInst {
    /// Returns the 'output' Output of this 'Pad' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'Pad' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'paddings' Input of this 'Pad' operation.
    pub fn paddings(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<PadInst> for crate::Operation {
    fn from(inst: PadInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Pad::new().build(input, paddings, scope)`.
pub fn pad<O0: ::std::convert::Into<crate::Output>, O1: ::std::convert::Into<crate::Output>>(
    input: O0,
    paddings: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Pad::new().build(input, paddings, scope)
}

/// Builder for the `PadV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct PadV2 {
    T: ::std::option::Option<crate::DataType>,
    Tpaddings: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'PadV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct PadV2Inst {
    /// An instance of a fully built PadV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl PadV2 {
    /// Creates a new `PadV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tpaddings` attribute.
    pub fn Tpaddings<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tpaddings = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `PadV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        paddings: O1,
        constant_values: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), paddings.into(), constant_values.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        paddings: crate::Output,
        constant_values: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("PadV2", |nd| {
            nd.add_input(input);
            nd.add_input(paddings);
            nd.add_input(constant_values);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tpaddings {
                nd.set_attr_type("Tpaddings", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'PadV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        paddings: crate::Output,
        constant_values: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<PadV2Inst> {
        let op = scope.new_operation("PadV2", |builder| {
            builder.add_input(input);
            builder.add_input(paddings);
            builder.add_input(constant_values);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tpaddings {
                builder.set_attr_type("Tpaddings", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(PadV2Inst { op })
    }
}
impl PadV2Inst {
    /// Returns the 'output' Output of this 'PadV2' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'PadV2' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'paddings' Input of this 'PadV2' operation.
    pub fn paddings(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'constant_values' Input of this 'PadV2' operation.
    pub fn constant_values(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<PadV2Inst> for crate::Operation {
    fn from(inst: PadV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `PadV2::new().build(input, paddings, constant_values, scope)`.
pub fn pad_v2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    input: O0,
    paddings: O1,
    constant_values: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    PadV2::new().build(input, paddings, constant_values, scope)
}

/// Builder for the `PaddedBatchDataset` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct PaddedBatchDataset {
    Toutput_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    N: ::std::option::Option<i64>,
    metadata: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'PaddedBatchDataset' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct PaddedBatchDatasetInst {
    /// An instance of a fully built PaddedBatchDataset Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl PaddedBatchDataset {
    /// Creates a new `PaddedBatchDataset`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `Toutput_types` attribute.
    pub fn Toutput_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Toutput_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `N` attribute.
    pub fn N<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.N = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `metadata` attribute.
    pub fn metadata<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.metadata = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `PaddedBatchDataset` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input_dataset: O0,
        batch_size: O1,
        padded_shapes: O2,
        padding_values: O3,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            input_dataset.into(),
            batch_size.into(),
            padded_shapes.into(),
            padding_values.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        input_dataset: crate::Output,
        batch_size: crate::Output,
        padded_shapes: crate::Output,
        padding_values: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("PaddedBatchDataset", |nd| {
            nd.add_input(input_dataset);
            nd.add_input(batch_size);
            nd.add_input(padded_shapes);
            nd.add_input(padding_values);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.Toutput_types {
                nd.set_attr_type_list("Toutput_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.N {
                nd.set_attr_int("N", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.metadata {
                nd.set_attr_string("metadata", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'PaddedBatchDataset' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_dataset: crate::Output,
        batch_size: crate::Output,
        padded_shapes: Vec<crate::Output>,
        padding_values: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<PaddedBatchDatasetInst> {
        let op = scope.new_operation("PaddedBatchDataset", |builder| {
            builder.add_input(input_dataset);
            builder.add_input(batch_size);
            builder.add_input_list(&padded_shapes);
            builder.add_input(padding_values);
            if let ::std::option::Option::Some(value) = &self.Toutput_types {
                builder.set_attr_type_list("Toutput_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            builder.set_attr_int("N", padded_shapes.clone().len() as i64)?;
            if let ::std::option::Option::Some(value) = &self.metadata {
                builder.set_attr_string("metadata", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(PaddedBatchDatasetInst { op })
    }
}
impl PaddedBatchDatasetInst {
    /// Returns the 'handle' Output of this 'PaddedBatchDataset' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_dataset' Input of this 'PaddedBatchDataset' operation.
    pub fn input_dataset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'batch_size' Input of this 'PaddedBatchDataset' operation.
    pub fn batch_size(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns a Vector of padded_shapes for 'padded_shapes' Input of this PaddedBatchDataset operation.
    pub fn padded_shapes(&self) -> crate::Result<Vec<crate::Input>> {
        let mut Inputs = vec![];
        for i in 2..self.op.get_attr_int("N")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
    /// Returns the 'padding_values' Input of this 'PaddedBatchDataset' operation.
    pub fn padding_values(&self) -> crate::Result<crate::Input> {
        let dynamic_offset = (self.op.get_attr_int("N")? + 3) as i32;
        Ok(crate::Input {
            operation: &self.op,
            index: dynamic_offset,
        })
    }
}
impl From<PaddedBatchDatasetInst> for crate::Operation {
    fn from(inst: PaddedBatchDatasetInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `PaddedBatchDataset::new().build(input_dataset, batch_size, padded_shapes, padding_values, scope)`.
pub fn padded_batch_dataset<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
>(
    input_dataset: O0,
    batch_size: O1,
    padded_shapes: O2,
    padding_values: O3,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    PaddedBatchDataset::new().build(
        input_dataset,
        batch_size,
        padded_shapes,
        padding_values,
        scope,
    )
}

/// Builder for the `PaddedBatchDatasetV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct PaddedBatchDatasetV2 {
    parallel_copy: ::std::option::Option<bool>,
    Toutput_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    N: ::std::option::Option<i64>,
    metadata: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'PaddedBatchDatasetV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct PaddedBatchDatasetV2Inst {
    /// An instance of a fully built PaddedBatchDatasetV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl PaddedBatchDatasetV2 {
    /// Creates a new `PaddedBatchDatasetV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `parallel_copy` attribute.
    pub fn parallel_copy<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.parallel_copy = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Toutput_types` attribute.
    pub fn Toutput_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Toutput_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `N` attribute.
    pub fn N<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.N = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `metadata` attribute.
    pub fn metadata<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.metadata = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `PaddedBatchDatasetV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input_dataset: O0,
        batch_size: O1,
        padded_shapes: O2,
        padding_values: O3,
        drop_remainder: O4,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            input_dataset.into(),
            batch_size.into(),
            padded_shapes.into(),
            padding_values.into(),
            drop_remainder.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        input_dataset: crate::Output,
        batch_size: crate::Output,
        padded_shapes: crate::Output,
        padding_values: crate::Output,
        drop_remainder: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("PaddedBatchDatasetV2", |nd| {
            nd.add_input(input_dataset);
            nd.add_input(batch_size);
            nd.add_input(padded_shapes);
            nd.add_input(padding_values);
            nd.add_input(drop_remainder);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.parallel_copy {
                nd.set_attr_bool("parallel_copy", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Toutput_types {
                nd.set_attr_type_list("Toutput_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.N {
                nd.set_attr_int("N", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.metadata {
                nd.set_attr_string("metadata", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'PaddedBatchDatasetV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_dataset: crate::Output,
        batch_size: crate::Output,
        padded_shapes: Vec<crate::Output>,
        padding_values: crate::Output,
        drop_remainder: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<PaddedBatchDatasetV2Inst> {
        let op = scope.new_operation("PaddedBatchDatasetV2", |builder| {
            builder.add_input(input_dataset);
            builder.add_input(batch_size);
            builder.add_input_list(&padded_shapes);
            builder.add_input(padding_values);
            builder.add_input(drop_remainder);
            if let ::std::option::Option::Some(value) = &self.parallel_copy {
                builder.set_attr_bool("parallel_copy", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Toutput_types {
                builder.set_attr_type_list("Toutput_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            builder.set_attr_int("N", padded_shapes.clone().len() as i64)?;
            if let ::std::option::Option::Some(value) = &self.metadata {
                builder.set_attr_string("metadata", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(PaddedBatchDatasetV2Inst { op })
    }
}
impl PaddedBatchDatasetV2Inst {
    /// Returns the 'handle' Output of this 'PaddedBatchDatasetV2' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_dataset' Input of this 'PaddedBatchDatasetV2' operation.
    pub fn input_dataset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'batch_size' Input of this 'PaddedBatchDatasetV2' operation.
    pub fn batch_size(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns a Vector of padded_shapes for 'padded_shapes' Input of this PaddedBatchDatasetV2 operation.
    pub fn padded_shapes(&self) -> crate::Result<Vec<crate::Input>> {
        let mut Inputs = vec![];
        for i in 2..self.op.get_attr_int("N")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
    /// Returns the 'padding_values' Input of this 'PaddedBatchDatasetV2' operation.
    pub fn padding_values(&self) -> crate::Result<crate::Input> {
        let dynamic_offset = (self.op.get_attr_int("N")? + 3) as i32;
        Ok(crate::Input {
            operation: &self.op,
            index: dynamic_offset,
        })
    }
    /// Returns the 'drop_remainder' Input of this 'PaddedBatchDatasetV2' operation.
    pub fn drop_remainder(&self) -> crate::Result<crate::Input> {
        let dynamic_offset = (self.op.get_attr_int("N")? + 4) as i32;
        Ok(crate::Input {
            operation: &self.op,
            index: dynamic_offset,
        })
    }
}
impl From<PaddedBatchDatasetV2Inst> for crate::Operation {
    fn from(inst: PaddedBatchDatasetV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `PaddedBatchDatasetV2::new().build(input_dataset, batch_size, padded_shapes, padding_values, drop_remainder, scope)`.
pub fn padded_batch_dataset_v2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
>(
    input_dataset: O0,
    batch_size: O1,
    padded_shapes: O2,
    padding_values: O3,
    drop_remainder: O4,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    PaddedBatchDatasetV2::new().build(
        input_dataset,
        batch_size,
        padded_shapes,
        padding_values,
        drop_remainder,
        scope,
    )
}

/// Builder for the `PaddingFIFOQueue` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct PaddingFIFOQueue {
    component_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    capacity: ::std::option::Option<i64>,
    container: ::std::option::Option<::std::string::String>,
    shared_name: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'PaddingFIFOQueue' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct PaddingFIFOQueueInst {
    /// An instance of a fully built PaddingFIFOQueue Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl PaddingFIFOQueue {
    /// Creates a new `PaddingFIFOQueue`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `component_types` attribute.
    pub fn component_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.component_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shapes` attribute.
    pub fn shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `capacity` attribute.
    pub fn capacity<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.capacity = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `container` attribute.
    pub fn container<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.container = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shared_name` attribute.
    pub fn shared_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.shared_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `PaddingFIFOQueue` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("PaddingFIFOQueue", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.component_types {
                nd.set_attr_type_list("component_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shapes {
                nd.set_attr_shape_list("shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.capacity {
                nd.set_attr_int("capacity", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.container {
                nd.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                nd.set_attr_string("shared_name", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'PaddingFIFOQueue' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(&self, scope: &mut crate::Scope) -> crate::Result<PaddingFIFOQueueInst> {
        let op = scope.new_operation("PaddingFIFOQueue", |builder| {
            if let ::std::option::Option::Some(value) = &self.component_types {
                builder.set_attr_type_list("component_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shapes {
                builder.set_attr_shape_list("shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.capacity {
                builder.set_attr_int("capacity", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.container {
                builder.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                builder.set_attr_string("shared_name", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(PaddingFIFOQueueInst { op })
    }
}
impl PaddingFIFOQueueInst {
    /// Returns the 'handle' Output of this 'PaddingFIFOQueue' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
}
impl From<PaddingFIFOQueueInst> for crate::Operation {
    fn from(inst: PaddingFIFOQueueInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `PaddingFIFOQueue::new().build(scope)`.
pub fn padding_fifoqueue(scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
    PaddingFIFOQueue::new().build(scope)
}

/// Builder for the `PaddingFIFOQueueV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct PaddingFIFOQueueV2 {
    component_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    capacity: ::std::option::Option<i64>,
    container: ::std::option::Option<::std::string::String>,
    shared_name: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'PaddingFIFOQueueV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct PaddingFIFOQueueV2Inst {
    /// An instance of a fully built PaddingFIFOQueueV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl PaddingFIFOQueueV2 {
    /// Creates a new `PaddingFIFOQueueV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `component_types` attribute.
    pub fn component_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.component_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shapes` attribute.
    pub fn shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `capacity` attribute.
    pub fn capacity<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.capacity = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `container` attribute.
    pub fn container<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.container = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shared_name` attribute.
    pub fn shared_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.shared_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `PaddingFIFOQueueV2` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("PaddingFIFOQueueV2", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.component_types {
                nd.set_attr_type_list("component_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shapes {
                nd.set_attr_shape_list("shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.capacity {
                nd.set_attr_int("capacity", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.container {
                nd.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                nd.set_attr_string("shared_name", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'PaddingFIFOQueueV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        scope: &mut crate::Scope,
    ) -> crate::Result<PaddingFIFOQueueV2Inst> {
        let op = scope.new_operation("PaddingFIFOQueueV2", |builder| {
            if let ::std::option::Option::Some(value) = &self.component_types {
                builder.set_attr_type_list("component_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shapes {
                builder.set_attr_shape_list("shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.capacity {
                builder.set_attr_int("capacity", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.container {
                builder.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                builder.set_attr_string("shared_name", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(PaddingFIFOQueueV2Inst { op })
    }
}
impl PaddingFIFOQueueV2Inst {
    /// Returns the 'handle' Output of this 'PaddingFIFOQueueV2' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
}
impl From<PaddingFIFOQueueV2Inst> for crate::Operation {
    fn from(inst: PaddingFIFOQueueV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `PaddingFIFOQueueV2::new().build(scope)`.
pub fn padding_fifoqueue_v2(scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
    PaddingFIFOQueueV2::new().build(scope)
}

/// Builder for the `ParallelBatchDataset` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ParallelBatchDataset {
    parallel_copy: ::std::option::Option<bool>,
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    deterministic: ::std::option::Option<::std::string::String>,
    metadata: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ParallelBatchDataset' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ParallelBatchDatasetInst {
    /// An instance of a fully built ParallelBatchDataset Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ParallelBatchDataset {
    /// Creates a new `ParallelBatchDataset`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `parallel_copy` attribute.
    pub fn parallel_copy<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.parallel_copy = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `deterministic` attribute.
    pub fn deterministic<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.deterministic = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `metadata` attribute.
    pub fn metadata<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.metadata = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ParallelBatchDataset` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input_dataset: O0,
        batch_size: O1,
        num_parallel_calls: O2,
        drop_remainder: O3,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            input_dataset.into(),
            batch_size.into(),
            num_parallel_calls.into(),
            drop_remainder.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        input_dataset: crate::Output,
        batch_size: crate::Output,
        num_parallel_calls: crate::Output,
        drop_remainder: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ParallelBatchDataset", |nd| {
            nd.add_input(input_dataset);
            nd.add_input(batch_size);
            nd.add_input(num_parallel_calls);
            nd.add_input(drop_remainder);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.parallel_copy {
                nd.set_attr_bool("parallel_copy", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.deterministic {
                nd.set_attr_string("deterministic", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.metadata {
                nd.set_attr_string("metadata", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ParallelBatchDataset' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_dataset: crate::Output,
        batch_size: crate::Output,
        num_parallel_calls: crate::Output,
        drop_remainder: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ParallelBatchDatasetInst> {
        let op = scope.new_operation("ParallelBatchDataset", |builder| {
            builder.add_input(input_dataset);
            builder.add_input(batch_size);
            builder.add_input(num_parallel_calls);
            builder.add_input(drop_remainder);
            if let ::std::option::Option::Some(value) = &self.parallel_copy {
                builder.set_attr_bool("parallel_copy", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.deterministic {
                builder.set_attr_string("deterministic", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.metadata {
                builder.set_attr_string("metadata", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ParallelBatchDatasetInst { op })
    }
}
impl ParallelBatchDatasetInst {
    /// Returns the 'handle' Output of this 'ParallelBatchDataset' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_dataset' Input of this 'ParallelBatchDataset' operation.
    pub fn input_dataset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'batch_size' Input of this 'ParallelBatchDataset' operation.
    pub fn batch_size(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'num_parallel_calls' Input of this 'ParallelBatchDataset' operation.
    pub fn num_parallel_calls(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'drop_remainder' Input of this 'ParallelBatchDataset' operation.
    pub fn drop_remainder(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
}
impl From<ParallelBatchDatasetInst> for crate::Operation {
    fn from(inst: ParallelBatchDatasetInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ParallelBatchDataset::new().build(input_dataset, batch_size, num_parallel_calls, drop_remainder, scope)`.
pub fn parallel_batch_dataset<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
>(
    input_dataset: O0,
    batch_size: O1,
    num_parallel_calls: O2,
    drop_remainder: O3,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ParallelBatchDataset::new().build(
        input_dataset,
        batch_size,
        num_parallel_calls,
        drop_remainder,
        scope,
    )
}

/// Builder for the `ParallelConcat` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ParallelConcat {
    N: ::std::option::Option<i64>,
    T: ::std::option::Option<crate::DataType>,
    shape: ::std::option::Option<crate::Shape>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ParallelConcat' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ParallelConcatInst {
    /// An instance of a fully built ParallelConcat Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ParallelConcat {
    /// Creates a new `ParallelConcat`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `N` attribute.
    pub fn N<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.N = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shape` attribute.
    pub fn shape<ArgType: ::std::convert::Into<crate::Shape>>(mut self, value: ArgType) -> Self {
        self.shape = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ParallelConcat` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        values: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(values.into(), scope)
    }
    fn build_impl(
        &self,
        values: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ParallelConcat", |nd| {
            nd.add_input(values);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.N {
                nd.set_attr_int("N", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shape {
                nd.set_attr_shape("shape", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ParallelConcat' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        values: Vec<crate::Output>,
        scope: &mut crate::Scope,
    ) -> crate::Result<ParallelConcatInst> {
        let op = scope.new_operation("ParallelConcat", |builder| {
            builder.add_input_list(&values);
            builder.set_attr_int("N", values.clone().len() as i64)?;
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shape {
                builder.set_attr_shape("shape", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ParallelConcatInst { op })
    }
}
impl ParallelConcatInst {
    /// Returns the 'output' Output of this 'ParallelConcat' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns a Vector of values for 'values' Input of this ParallelConcat operation.
    pub fn values(&self) -> crate::Result<Vec<crate::Input>> {
        let mut Inputs = vec![];
        for i in 0..self.op.get_attr_int("N")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
}
impl From<ParallelConcatInst> for crate::Operation {
    fn from(inst: ParallelConcatInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ParallelConcat::new().build(values, scope)`.
pub fn parallel_concat<O0: ::std::convert::Into<crate::Output>>(
    values: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ParallelConcat::new().build(values, scope)
}

/// Builder for the `ParallelDynamicStitch` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ParallelDynamicStitch {
    N: ::std::option::Option<i64>,
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ParallelDynamicStitch' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ParallelDynamicStitchInst {
    /// An instance of a fully built ParallelDynamicStitch Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ParallelDynamicStitch {
    /// Creates a new `ParallelDynamicStitch`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `N` attribute.
    pub fn N<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.N = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ParallelDynamicStitch` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        indices: O0,
        data: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(indices.into(), data.into(), scope)
    }
    fn build_impl(
        &self,
        indices: crate::Output,
        data: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ParallelDynamicStitch", |nd| {
            nd.add_input(indices);
            nd.add_input(data);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.N {
                nd.set_attr_int("N", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ParallelDynamicStitch' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        indices: Vec<crate::Output>,
        data: Vec<crate::Output>,
        scope: &mut crate::Scope,
    ) -> crate::Result<ParallelDynamicStitchInst> {
        let op = scope.new_operation("ParallelDynamicStitch", |builder| {
            builder.add_input_list(&indices);
            builder.add_input_list(&data);
            builder.set_attr_int("N", indices.clone().len() as i64)?;
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ParallelDynamicStitchInst { op })
    }
}
impl ParallelDynamicStitchInst {
    /// Returns the 'merged' Output of this 'ParallelDynamicStitch' operation.
    pub fn merged(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns a Vector of indices for 'indices' Input of this ParallelDynamicStitch operation.
    pub fn indices(&self) -> crate::Result<Vec<crate::Input>> {
        let mut Inputs = vec![];
        for i in 0..self.op.get_attr_int("N")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
    /// Returns a Vector of data for 'data' Input of this ParallelDynamicStitch operation.
    pub fn data(&self) -> crate::Result<Vec<crate::Input>> {
        let dynamic_offset = (self.op.get_attr_int("N")? + 1) as i32;
        let mut Inputs = vec![];
        for i in dynamic_offset..dynamic_offset + self.op.get_attr_int("N")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
}
impl From<ParallelDynamicStitchInst> for crate::Operation {
    fn from(inst: ParallelDynamicStitchInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ParallelDynamicStitch::new().build(indices, data, scope)`.
pub fn parallel_dynamic_stitch<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    indices: O0,
    data: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ParallelDynamicStitch::new().build(indices, data, scope)
}

/// Builder for the `ParallelFilterDataset` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ParallelFilterDataset {
    predicate: ::std::option::Option<::std::string::String>,
    deterministic: ::std::option::Option<::std::string::String>,
    Targuments: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    metadata: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ParallelFilterDataset' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ParallelFilterDatasetInst {
    /// An instance of a fully built ParallelFilterDataset Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ParallelFilterDataset {
    /// Creates a new `ParallelFilterDataset`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `predicate` attribute.
    pub fn predicate<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.predicate = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `deterministic` attribute.
    pub fn deterministic<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.deterministic = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Targuments` attribute.
    pub fn Targuments<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Targuments = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `metadata` attribute.
    pub fn metadata<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.metadata = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ParallelFilterDataset` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input_dataset: O0,
        other_arguments: O1,
        num_parallel_calls: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            input_dataset.into(),
            other_arguments.into(),
            num_parallel_calls.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        input_dataset: crate::Output,
        other_arguments: crate::Output,
        num_parallel_calls: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ParallelFilterDataset", |nd| {
            nd.add_input(input_dataset);
            nd.add_input(other_arguments);
            nd.add_input(num_parallel_calls);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.predicate {
                nd.set_attr_string("predicate", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.deterministic {
                nd.set_attr_string("deterministic", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Targuments {
                nd.set_attr_type_list("Targuments", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.metadata {
                nd.set_attr_string("metadata", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ParallelFilterDataset' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_dataset: crate::Output,
        other_arguments: crate::Output,
        num_parallel_calls: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ParallelFilterDatasetInst> {
        let op = scope.new_operation("ParallelFilterDataset", |builder| {
            builder.add_input(input_dataset);
            builder.add_input(other_arguments);
            builder.add_input(num_parallel_calls);
            if let ::std::option::Option::Some(value) = &self.predicate {
                builder.set_attr_string("predicate", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.deterministic {
                builder.set_attr_string("deterministic", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Targuments {
                builder.set_attr_type_list("Targuments", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.metadata {
                builder.set_attr_string("metadata", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ParallelFilterDatasetInst { op })
    }
}
impl ParallelFilterDatasetInst {
    /// Returns the 'handle' Output of this 'ParallelFilterDataset' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_dataset' Input of this 'ParallelFilterDataset' operation.
    pub fn input_dataset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'other_arguments' Input of this 'ParallelFilterDataset' operation.
    pub fn other_arguments(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'num_parallel_calls' Input of this 'ParallelFilterDataset' operation.
    pub fn num_parallel_calls(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<ParallelFilterDatasetInst> for crate::Operation {
    fn from(inst: ParallelFilterDatasetInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ParallelFilterDataset::new().build(input_dataset, other_arguments, num_parallel_calls, scope)`.
pub fn parallel_filter_dataset<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    input_dataset: O0,
    other_arguments: O1,
    num_parallel_calls: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ParallelFilterDataset::new().build(input_dataset, other_arguments, num_parallel_calls, scope)
}

/// Builder for the `ParallelInterleaveDataset` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ParallelInterleaveDataset {
    f: ::std::option::Option<::std::string::String>,
    Targuments: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    metadata: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ParallelInterleaveDataset' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ParallelInterleaveDatasetInst {
    /// An instance of a fully built ParallelInterleaveDataset Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ParallelInterleaveDataset {
    /// Creates a new `ParallelInterleaveDataset`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `f` attribute.
    pub fn f<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.f = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Targuments` attribute.
    pub fn Targuments<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Targuments = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `metadata` attribute.
    pub fn metadata<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.metadata = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ParallelInterleaveDataset` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
        O6: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input_dataset: O0,
        other_arguments: O1,
        cycle_length: O2,
        block_length: O3,
        sloppy: O4,
        buffer_output_elements: O5,
        prefetch_input_elements: O6,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            input_dataset.into(),
            other_arguments.into(),
            cycle_length.into(),
            block_length.into(),
            sloppy.into(),
            buffer_output_elements.into(),
            prefetch_input_elements.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        input_dataset: crate::Output,
        other_arguments: crate::Output,
        cycle_length: crate::Output,
        block_length: crate::Output,
        sloppy: crate::Output,
        buffer_output_elements: crate::Output,
        prefetch_input_elements: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ParallelInterleaveDataset", |nd| {
            nd.add_input(input_dataset);
            nd.add_input(other_arguments);
            nd.add_input(cycle_length);
            nd.add_input(block_length);
            nd.add_input(sloppy);
            nd.add_input(buffer_output_elements);
            nd.add_input(prefetch_input_elements);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.f {
                nd.set_attr_string("f", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Targuments {
                nd.set_attr_type_list("Targuments", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.metadata {
                nd.set_attr_string("metadata", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ParallelInterleaveDataset' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_dataset: crate::Output,
        other_arguments: crate::Output,
        cycle_length: crate::Output,
        block_length: crate::Output,
        sloppy: crate::Output,
        buffer_output_elements: crate::Output,
        prefetch_input_elements: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ParallelInterleaveDatasetInst> {
        let op = scope.new_operation("ParallelInterleaveDataset", |builder| {
            builder.add_input(input_dataset);
            builder.add_input(other_arguments);
            builder.add_input(cycle_length);
            builder.add_input(block_length);
            builder.add_input(sloppy);
            builder.add_input(buffer_output_elements);
            builder.add_input(prefetch_input_elements);
            if let ::std::option::Option::Some(value) = &self.f {
                builder.set_attr_string("f", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Targuments {
                builder.set_attr_type_list("Targuments", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.metadata {
                builder.set_attr_string("metadata", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ParallelInterleaveDatasetInst { op })
    }
}
impl ParallelInterleaveDatasetInst {
    /// Returns the 'handle' Output of this 'ParallelInterleaveDataset' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_dataset' Input of this 'ParallelInterleaveDataset' operation.
    pub fn input_dataset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'other_arguments' Input of this 'ParallelInterleaveDataset' operation.
    pub fn other_arguments(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'cycle_length' Input of this 'ParallelInterleaveDataset' operation.
    pub fn cycle_length(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'block_length' Input of this 'ParallelInterleaveDataset' operation.
    pub fn block_length(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'sloppy' Input of this 'ParallelInterleaveDataset' operation.
    pub fn sloppy(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
    /// Returns the 'buffer_output_elements' Input of this 'ParallelInterleaveDataset' operation.
    pub fn buffer_output_elements(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 5,
        }
    }
    /// Returns the 'prefetch_input_elements' Input of this 'ParallelInterleaveDataset' operation.
    pub fn prefetch_input_elements(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 6,
        }
    }
}
impl From<ParallelInterleaveDatasetInst> for crate::Operation {
    fn from(inst: ParallelInterleaveDatasetInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ParallelInterleaveDataset::new().build(input_dataset, other_arguments, cycle_length, block_length, sloppy, buffer_output_elements, prefetch_input_elements, scope)`.
pub fn parallel_interleave_dataset<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
    O6: ::std::convert::Into<crate::Output>,
>(
    input_dataset: O0,
    other_arguments: O1,
    cycle_length: O2,
    block_length: O3,
    sloppy: O4,
    buffer_output_elements: O5,
    prefetch_input_elements: O6,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ParallelInterleaveDataset::new().build(
        input_dataset,
        other_arguments,
        cycle_length,
        block_length,
        sloppy,
        buffer_output_elements,
        prefetch_input_elements,
        scope,
    )
}

/// Builder for the `ParallelInterleaveDatasetV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ParallelInterleaveDatasetV2 {
    f: ::std::option::Option<::std::string::String>,
    Targuments: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    sloppy: ::std::option::Option<bool>,
    metadata: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ParallelInterleaveDatasetV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ParallelInterleaveDatasetV2Inst {
    /// An instance of a fully built ParallelInterleaveDatasetV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ParallelInterleaveDatasetV2 {
    /// Creates a new `ParallelInterleaveDatasetV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `f` attribute.
    pub fn f<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.f = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Targuments` attribute.
    pub fn Targuments<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Targuments = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `sloppy` attribute.
    pub fn sloppy<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.sloppy = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `metadata` attribute.
    pub fn metadata<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.metadata = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ParallelInterleaveDatasetV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input_dataset: O0,
        other_arguments: O1,
        cycle_length: O2,
        block_length: O3,
        num_parallel_calls: O4,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            input_dataset.into(),
            other_arguments.into(),
            cycle_length.into(),
            block_length.into(),
            num_parallel_calls.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        input_dataset: crate::Output,
        other_arguments: crate::Output,
        cycle_length: crate::Output,
        block_length: crate::Output,
        num_parallel_calls: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ParallelInterleaveDatasetV2", |nd| {
            nd.add_input(input_dataset);
            nd.add_input(other_arguments);
            nd.add_input(cycle_length);
            nd.add_input(block_length);
            nd.add_input(num_parallel_calls);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.f {
                nd.set_attr_string("f", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Targuments {
                nd.set_attr_type_list("Targuments", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.sloppy {
                nd.set_attr_bool("sloppy", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.metadata {
                nd.set_attr_string("metadata", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ParallelInterleaveDatasetV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_dataset: crate::Output,
        other_arguments: crate::Output,
        cycle_length: crate::Output,
        block_length: crate::Output,
        num_parallel_calls: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ParallelInterleaveDatasetV2Inst> {
        let op = scope.new_operation("ParallelInterleaveDatasetV2", |builder| {
            builder.add_input(input_dataset);
            builder.add_input(other_arguments);
            builder.add_input(cycle_length);
            builder.add_input(block_length);
            builder.add_input(num_parallel_calls);
            if let ::std::option::Option::Some(value) = &self.f {
                builder.set_attr_string("f", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Targuments {
                builder.set_attr_type_list("Targuments", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.sloppy {
                builder.set_attr_bool("sloppy", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.metadata {
                builder.set_attr_string("metadata", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ParallelInterleaveDatasetV2Inst { op })
    }
}
impl ParallelInterleaveDatasetV2Inst {
    /// Returns the 'handle' Output of this 'ParallelInterleaveDatasetV2' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_dataset' Input of this 'ParallelInterleaveDatasetV2' operation.
    pub fn input_dataset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'other_arguments' Input of this 'ParallelInterleaveDatasetV2' operation.
    pub fn other_arguments(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'cycle_length' Input of this 'ParallelInterleaveDatasetV2' operation.
    pub fn cycle_length(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'block_length' Input of this 'ParallelInterleaveDatasetV2' operation.
    pub fn block_length(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'num_parallel_calls' Input of this 'ParallelInterleaveDatasetV2' operation.
    pub fn num_parallel_calls(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
}
impl From<ParallelInterleaveDatasetV2Inst> for crate::Operation {
    fn from(inst: ParallelInterleaveDatasetV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ParallelInterleaveDatasetV2::new().build(input_dataset, other_arguments, cycle_length, block_length, num_parallel_calls, scope)`.
pub fn parallel_interleave_dataset_v2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
>(
    input_dataset: O0,
    other_arguments: O1,
    cycle_length: O2,
    block_length: O3,
    num_parallel_calls: O4,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ParallelInterleaveDatasetV2::new().build(
        input_dataset,
        other_arguments,
        cycle_length,
        block_length,
        num_parallel_calls,
        scope,
    )
}

/// Builder for the `ParallelInterleaveDatasetV3` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ParallelInterleaveDatasetV3 {
    f: ::std::option::Option<::std::string::String>,
    deterministic: ::std::option::Option<::std::string::String>,
    Targuments: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    metadata: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ParallelInterleaveDatasetV3' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ParallelInterleaveDatasetV3Inst {
    /// An instance of a fully built ParallelInterleaveDatasetV3 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ParallelInterleaveDatasetV3 {
    /// Creates a new `ParallelInterleaveDatasetV3`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `f` attribute.
    pub fn f<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.f = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `deterministic` attribute.
    pub fn deterministic<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.deterministic = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Targuments` attribute.
    pub fn Targuments<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Targuments = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `metadata` attribute.
    pub fn metadata<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.metadata = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ParallelInterleaveDatasetV3` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input_dataset: O0,
        other_arguments: O1,
        cycle_length: O2,
        block_length: O3,
        num_parallel_calls: O4,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            input_dataset.into(),
            other_arguments.into(),
            cycle_length.into(),
            block_length.into(),
            num_parallel_calls.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        input_dataset: crate::Output,
        other_arguments: crate::Output,
        cycle_length: crate::Output,
        block_length: crate::Output,
        num_parallel_calls: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ParallelInterleaveDatasetV3", |nd| {
            nd.add_input(input_dataset);
            nd.add_input(other_arguments);
            nd.add_input(cycle_length);
            nd.add_input(block_length);
            nd.add_input(num_parallel_calls);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.f {
                nd.set_attr_string("f", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.deterministic {
                nd.set_attr_string("deterministic", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Targuments {
                nd.set_attr_type_list("Targuments", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.metadata {
                nd.set_attr_string("metadata", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ParallelInterleaveDatasetV3' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_dataset: crate::Output,
        other_arguments: crate::Output,
        cycle_length: crate::Output,
        block_length: crate::Output,
        num_parallel_calls: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ParallelInterleaveDatasetV3Inst> {
        let op = scope.new_operation("ParallelInterleaveDatasetV3", |builder| {
            builder.add_input(input_dataset);
            builder.add_input(other_arguments);
            builder.add_input(cycle_length);
            builder.add_input(block_length);
            builder.add_input(num_parallel_calls);
            if let ::std::option::Option::Some(value) = &self.f {
                builder.set_attr_string("f", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.deterministic {
                builder.set_attr_string("deterministic", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Targuments {
                builder.set_attr_type_list("Targuments", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.metadata {
                builder.set_attr_string("metadata", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ParallelInterleaveDatasetV3Inst { op })
    }
}
impl ParallelInterleaveDatasetV3Inst {
    /// Returns the 'handle' Output of this 'ParallelInterleaveDatasetV3' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_dataset' Input of this 'ParallelInterleaveDatasetV3' operation.
    pub fn input_dataset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'other_arguments' Input of this 'ParallelInterleaveDatasetV3' operation.
    pub fn other_arguments(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'cycle_length' Input of this 'ParallelInterleaveDatasetV3' operation.
    pub fn cycle_length(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'block_length' Input of this 'ParallelInterleaveDatasetV3' operation.
    pub fn block_length(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'num_parallel_calls' Input of this 'ParallelInterleaveDatasetV3' operation.
    pub fn num_parallel_calls(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
}
impl From<ParallelInterleaveDatasetV3Inst> for crate::Operation {
    fn from(inst: ParallelInterleaveDatasetV3Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ParallelInterleaveDatasetV3::new().build(input_dataset, other_arguments, cycle_length, block_length, num_parallel_calls, scope)`.
pub fn parallel_interleave_dataset_v3<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
>(
    input_dataset: O0,
    other_arguments: O1,
    cycle_length: O2,
    block_length: O3,
    num_parallel_calls: O4,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ParallelInterleaveDatasetV3::new().build(
        input_dataset,
        other_arguments,
        cycle_length,
        block_length,
        num_parallel_calls,
        scope,
    )
}

/// Builder for the `ParallelInterleaveDatasetV4` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ParallelInterleaveDatasetV4 {
    f: ::std::option::Option<::std::string::String>,
    deterministic: ::std::option::Option<::std::string::String>,
    Targuments: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    metadata: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ParallelInterleaveDatasetV4' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ParallelInterleaveDatasetV4Inst {
    /// An instance of a fully built ParallelInterleaveDatasetV4 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ParallelInterleaveDatasetV4 {
    /// Creates a new `ParallelInterleaveDatasetV4`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `f` attribute.
    pub fn f<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.f = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `deterministic` attribute.
    pub fn deterministic<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.deterministic = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Targuments` attribute.
    pub fn Targuments<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Targuments = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `metadata` attribute.
    pub fn metadata<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.metadata = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ParallelInterleaveDatasetV4` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
        O6: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input_dataset: O0,
        other_arguments: O1,
        cycle_length: O2,
        block_length: O3,
        buffer_output_elements: O4,
        prefetch_input_elements: O5,
        num_parallel_calls: O6,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            input_dataset.into(),
            other_arguments.into(),
            cycle_length.into(),
            block_length.into(),
            buffer_output_elements.into(),
            prefetch_input_elements.into(),
            num_parallel_calls.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        input_dataset: crate::Output,
        other_arguments: crate::Output,
        cycle_length: crate::Output,
        block_length: crate::Output,
        buffer_output_elements: crate::Output,
        prefetch_input_elements: crate::Output,
        num_parallel_calls: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ParallelInterleaveDatasetV4", |nd| {
            nd.add_input(input_dataset);
            nd.add_input(other_arguments);
            nd.add_input(cycle_length);
            nd.add_input(block_length);
            nd.add_input(buffer_output_elements);
            nd.add_input(prefetch_input_elements);
            nd.add_input(num_parallel_calls);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.f {
                nd.set_attr_string("f", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.deterministic {
                nd.set_attr_string("deterministic", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Targuments {
                nd.set_attr_type_list("Targuments", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.metadata {
                nd.set_attr_string("metadata", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ParallelInterleaveDatasetV4' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_dataset: crate::Output,
        other_arguments: crate::Output,
        cycle_length: crate::Output,
        block_length: crate::Output,
        buffer_output_elements: crate::Output,
        prefetch_input_elements: crate::Output,
        num_parallel_calls: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ParallelInterleaveDatasetV4Inst> {
        let op = scope.new_operation("ParallelInterleaveDatasetV4", |builder| {
            builder.add_input(input_dataset);
            builder.add_input(other_arguments);
            builder.add_input(cycle_length);
            builder.add_input(block_length);
            builder.add_input(buffer_output_elements);
            builder.add_input(prefetch_input_elements);
            builder.add_input(num_parallel_calls);
            if let ::std::option::Option::Some(value) = &self.f {
                builder.set_attr_string("f", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.deterministic {
                builder.set_attr_string("deterministic", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Targuments {
                builder.set_attr_type_list("Targuments", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.metadata {
                builder.set_attr_string("metadata", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ParallelInterleaveDatasetV4Inst { op })
    }
}
impl ParallelInterleaveDatasetV4Inst {
    /// Returns the 'handle' Output of this 'ParallelInterleaveDatasetV4' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_dataset' Input of this 'ParallelInterleaveDatasetV4' operation.
    pub fn input_dataset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'other_arguments' Input of this 'ParallelInterleaveDatasetV4' operation.
    pub fn other_arguments(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'cycle_length' Input of this 'ParallelInterleaveDatasetV4' operation.
    pub fn cycle_length(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'block_length' Input of this 'ParallelInterleaveDatasetV4' operation.
    pub fn block_length(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'buffer_output_elements' Input of this 'ParallelInterleaveDatasetV4' operation.
    pub fn buffer_output_elements(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
    /// Returns the 'prefetch_input_elements' Input of this 'ParallelInterleaveDatasetV4' operation.
    pub fn prefetch_input_elements(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 5,
        }
    }
    /// Returns the 'num_parallel_calls' Input of this 'ParallelInterleaveDatasetV4' operation.
    pub fn num_parallel_calls(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 6,
        }
    }
}
impl From<ParallelInterleaveDatasetV4Inst> for crate::Operation {
    fn from(inst: ParallelInterleaveDatasetV4Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ParallelInterleaveDatasetV4::new().build(input_dataset, other_arguments, cycle_length, block_length, buffer_output_elements, prefetch_input_elements, num_parallel_calls, scope)`.
pub fn parallel_interleave_dataset_v4<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
    O6: ::std::convert::Into<crate::Output>,
>(
    input_dataset: O0,
    other_arguments: O1,
    cycle_length: O2,
    block_length: O3,
    buffer_output_elements: O4,
    prefetch_input_elements: O5,
    num_parallel_calls: O6,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ParallelInterleaveDatasetV4::new().build(
        input_dataset,
        other_arguments,
        cycle_length,
        block_length,
        buffer_output_elements,
        prefetch_input_elements,
        num_parallel_calls,
        scope,
    )
}

/// Builder for the `ParallelMapDataset` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ParallelMapDataset {
    f: ::std::option::Option<::std::string::String>,
    Targuments: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    use_inter_op_parallelism: ::std::option::Option<bool>,
    sloppy: ::std::option::Option<bool>,
    preserve_cardinality: ::std::option::Option<bool>,
    metadata: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ParallelMapDataset' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ParallelMapDatasetInst {
    /// An instance of a fully built ParallelMapDataset Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ParallelMapDataset {
    /// Creates a new `ParallelMapDataset`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `f` attribute.
    pub fn f<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.f = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Targuments` attribute.
    pub fn Targuments<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Targuments = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_inter_op_parallelism` attribute.
    pub fn use_inter_op_parallelism<ArgType: ::std::convert::Into<bool>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.use_inter_op_parallelism = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `sloppy` attribute.
    pub fn sloppy<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.sloppy = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `preserve_cardinality` attribute.
    pub fn preserve_cardinality<ArgType: ::std::convert::Into<bool>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.preserve_cardinality = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `metadata` attribute.
    pub fn metadata<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.metadata = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ParallelMapDataset` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input_dataset: O0,
        other_arguments: O1,
        num_parallel_calls: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            input_dataset.into(),
            other_arguments.into(),
            num_parallel_calls.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        input_dataset: crate::Output,
        other_arguments: crate::Output,
        num_parallel_calls: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ParallelMapDataset", |nd| {
            nd.add_input(input_dataset);
            nd.add_input(other_arguments);
            nd.add_input(num_parallel_calls);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.f {
                nd.set_attr_string("f", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Targuments {
                nd.set_attr_type_list("Targuments", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_inter_op_parallelism {
                nd.set_attr_bool("use_inter_op_parallelism", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.sloppy {
                nd.set_attr_bool("sloppy", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.preserve_cardinality {
                nd.set_attr_bool("preserve_cardinality", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.metadata {
                nd.set_attr_string("metadata", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ParallelMapDataset' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_dataset: crate::Output,
        other_arguments: crate::Output,
        num_parallel_calls: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ParallelMapDatasetInst> {
        let op = scope.new_operation("ParallelMapDataset", |builder| {
            builder.add_input(input_dataset);
            builder.add_input(other_arguments);
            builder.add_input(num_parallel_calls);
            if let ::std::option::Option::Some(value) = &self.f {
                builder.set_attr_string("f", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Targuments {
                builder.set_attr_type_list("Targuments", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_inter_op_parallelism {
                builder.set_attr_bool("use_inter_op_parallelism", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.sloppy {
                builder.set_attr_bool("sloppy", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.preserve_cardinality {
                builder.set_attr_bool("preserve_cardinality", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.metadata {
                builder.set_attr_string("metadata", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ParallelMapDatasetInst { op })
    }
}
impl ParallelMapDatasetInst {
    /// Returns the 'handle' Output of this 'ParallelMapDataset' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_dataset' Input of this 'ParallelMapDataset' operation.
    pub fn input_dataset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'other_arguments' Input of this 'ParallelMapDataset' operation.
    pub fn other_arguments(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'num_parallel_calls' Input of this 'ParallelMapDataset' operation.
    pub fn num_parallel_calls(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<ParallelMapDatasetInst> for crate::Operation {
    fn from(inst: ParallelMapDatasetInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ParallelMapDataset::new().build(input_dataset, other_arguments, num_parallel_calls, scope)`.
pub fn parallel_map_dataset<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    input_dataset: O0,
    other_arguments: O1,
    num_parallel_calls: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ParallelMapDataset::new().build(input_dataset, other_arguments, num_parallel_calls, scope)
}

/// Builder for the `ParallelMapDatasetV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ParallelMapDatasetV2 {
    f: ::std::option::Option<::std::string::String>,
    Targuments: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    use_inter_op_parallelism: ::std::option::Option<bool>,
    deterministic: ::std::option::Option<::std::string::String>,
    preserve_cardinality: ::std::option::Option<bool>,
    metadata: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ParallelMapDatasetV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ParallelMapDatasetV2Inst {
    /// An instance of a fully built ParallelMapDatasetV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ParallelMapDatasetV2 {
    /// Creates a new `ParallelMapDatasetV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `f` attribute.
    pub fn f<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.f = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Targuments` attribute.
    pub fn Targuments<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Targuments = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_inter_op_parallelism` attribute.
    pub fn use_inter_op_parallelism<ArgType: ::std::convert::Into<bool>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.use_inter_op_parallelism = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `deterministic` attribute.
    pub fn deterministic<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.deterministic = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `preserve_cardinality` attribute.
    pub fn preserve_cardinality<ArgType: ::std::convert::Into<bool>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.preserve_cardinality = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `metadata` attribute.
    pub fn metadata<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.metadata = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ParallelMapDatasetV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input_dataset: O0,
        other_arguments: O1,
        num_parallel_calls: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            input_dataset.into(),
            other_arguments.into(),
            num_parallel_calls.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        input_dataset: crate::Output,
        other_arguments: crate::Output,
        num_parallel_calls: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ParallelMapDatasetV2", |nd| {
            nd.add_input(input_dataset);
            nd.add_input(other_arguments);
            nd.add_input(num_parallel_calls);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.f {
                nd.set_attr_string("f", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Targuments {
                nd.set_attr_type_list("Targuments", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_inter_op_parallelism {
                nd.set_attr_bool("use_inter_op_parallelism", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.deterministic {
                nd.set_attr_string("deterministic", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.preserve_cardinality {
                nd.set_attr_bool("preserve_cardinality", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.metadata {
                nd.set_attr_string("metadata", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ParallelMapDatasetV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_dataset: crate::Output,
        other_arguments: crate::Output,
        num_parallel_calls: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ParallelMapDatasetV2Inst> {
        let op = scope.new_operation("ParallelMapDatasetV2", |builder| {
            builder.add_input(input_dataset);
            builder.add_input(other_arguments);
            builder.add_input(num_parallel_calls);
            if let ::std::option::Option::Some(value) = &self.f {
                builder.set_attr_string("f", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Targuments {
                builder.set_attr_type_list("Targuments", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_inter_op_parallelism {
                builder.set_attr_bool("use_inter_op_parallelism", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.deterministic {
                builder.set_attr_string("deterministic", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.preserve_cardinality {
                builder.set_attr_bool("preserve_cardinality", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.metadata {
                builder.set_attr_string("metadata", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ParallelMapDatasetV2Inst { op })
    }
}
impl ParallelMapDatasetV2Inst {
    /// Returns the 'handle' Output of this 'ParallelMapDatasetV2' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_dataset' Input of this 'ParallelMapDatasetV2' operation.
    pub fn input_dataset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'other_arguments' Input of this 'ParallelMapDatasetV2' operation.
    pub fn other_arguments(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'num_parallel_calls' Input of this 'ParallelMapDatasetV2' operation.
    pub fn num_parallel_calls(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<ParallelMapDatasetV2Inst> for crate::Operation {
    fn from(inst: ParallelMapDatasetV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ParallelMapDatasetV2::new().build(input_dataset, other_arguments, num_parallel_calls, scope)`.
pub fn parallel_map_dataset_v2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    input_dataset: O0,
    other_arguments: O1,
    num_parallel_calls: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ParallelMapDatasetV2::new().build(input_dataset, other_arguments, num_parallel_calls, scope)
}

/// Builder for the `ParameterizedTruncatedNormal` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ParameterizedTruncatedNormal {
    seed: ::std::option::Option<i64>,
    seed2: ::std::option::Option<i64>,
    dtype: ::std::option::Option<crate::DataType>,
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ParameterizedTruncatedNormal' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ParameterizedTruncatedNormalInst {
    /// An instance of a fully built ParameterizedTruncatedNormal Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ParameterizedTruncatedNormal {
    /// Creates a new `ParameterizedTruncatedNormal`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `seed` attribute.
    pub fn seed<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.seed = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `seed2` attribute.
    pub fn seed2<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.seed2 = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `dtype` attribute.
    pub fn dtype<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ParameterizedTruncatedNormal` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
    >(
        &self,
        shape: O0,
        means: O1,
        stdevs: O2,
        minvals: O3,
        maxvals: O4,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            shape.into(),
            means.into(),
            stdevs.into(),
            minvals.into(),
            maxvals.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        shape: crate::Output,
        means: crate::Output,
        stdevs: crate::Output,
        minvals: crate::Output,
        maxvals: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ParameterizedTruncatedNormal", |nd| {
            nd.add_input(shape);
            nd.add_input(means);
            nd.add_input(stdevs);
            nd.add_input(minvals);
            nd.add_input(maxvals);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.seed {
                nd.set_attr_int("seed", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed2 {
                nd.set_attr_int("seed2", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                nd.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ParameterizedTruncatedNormal' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        shape: crate::Output,
        means: crate::Output,
        stdevs: crate::Output,
        minvals: crate::Output,
        maxvals: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ParameterizedTruncatedNormalInst> {
        let op = scope.new_operation("ParameterizedTruncatedNormal", |builder| {
            builder.add_input(shape);
            builder.add_input(means);
            builder.add_input(stdevs);
            builder.add_input(minvals);
            builder.add_input(maxvals);
            if let ::std::option::Option::Some(value) = &self.seed {
                builder.set_attr_int("seed", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed2 {
                builder.set_attr_int("seed2", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                builder.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ParameterizedTruncatedNormalInst { op })
    }
}
impl ParameterizedTruncatedNormalInst {
    /// Returns the 'output' Output of this 'ParameterizedTruncatedNormal' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'shape' Input of this 'ParameterizedTruncatedNormal' operation.
    pub fn shape(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'means' Input of this 'ParameterizedTruncatedNormal' operation.
    pub fn means(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'stdevs' Input of this 'ParameterizedTruncatedNormal' operation.
    pub fn stdevs(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'minvals' Input of this 'ParameterizedTruncatedNormal' operation.
    pub fn minvals(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'maxvals' Input of this 'ParameterizedTruncatedNormal' operation.
    pub fn maxvals(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
}
impl From<ParameterizedTruncatedNormalInst> for crate::Operation {
    fn from(inst: ParameterizedTruncatedNormalInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ParameterizedTruncatedNormal::new().build(shape, means, stdevs, minvals, maxvals, scope)`.
pub fn parameterized_truncated_normal<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
>(
    shape: O0,
    means: O1,
    stdevs: O2,
    minvals: O3,
    maxvals: O4,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ParameterizedTruncatedNormal::new().build(shape, means, stdevs, minvals, maxvals, scope)
}

/// Builder for the `ParseExample` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ParseExample {
    Nsparse: ::std::option::Option<i64>,
    Ndense: ::std::option::Option<i64>,
    sparse_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    Tdense: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    dense_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ParseExample' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ParseExampleInst {
    /// An instance of a fully built ParseExample Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ParseExample {
    /// Creates a new `ParseExample`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `Nsparse` attribute.
    pub fn Nsparse<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.Nsparse = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Ndense` attribute.
    pub fn Ndense<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.Ndense = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `sparse_types` attribute.
    pub fn sparse_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.sparse_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tdense` attribute.
    pub fn Tdense<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tdense = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `dense_shapes` attribute.
    pub fn dense_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.dense_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ParseExample` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
    >(
        &self,
        serialized: O0,
        names: O1,
        sparse_keys: O2,
        dense_keys: O3,
        dense_defaults: O4,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            serialized.into(),
            names.into(),
            sparse_keys.into(),
            dense_keys.into(),
            dense_defaults.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        serialized: crate::Output,
        names: crate::Output,
        sparse_keys: crate::Output,
        dense_keys: crate::Output,
        dense_defaults: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ParseExample", |nd| {
            nd.add_input(serialized);
            nd.add_input(names);
            nd.add_input(sparse_keys);
            nd.add_input(dense_keys);
            nd.add_input(dense_defaults);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.Nsparse {
                nd.set_attr_int("Nsparse", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Ndense {
                nd.set_attr_int("Ndense", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.sparse_types {
                nd.set_attr_type_list("sparse_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tdense {
                nd.set_attr_type_list("Tdense", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dense_shapes {
                nd.set_attr_shape_list("dense_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ParseExample' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        serialized: crate::Output,
        names: crate::Output,
        sparse_keys: Vec<crate::Output>,
        dense_keys: Vec<crate::Output>,
        dense_defaults: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ParseExampleInst> {
        let op = scope.new_operation("ParseExample", |builder| {
            builder.add_input(serialized);
            builder.add_input(names);
            builder.add_input_list(&sparse_keys);
            builder.add_input_list(&dense_keys);
            builder.add_input(dense_defaults);
            builder.set_attr_int("Nsparse", sparse_keys.clone().len() as i64)?;
            builder.set_attr_int("Ndense", dense_keys.clone().len() as i64)?;
            if let ::std::option::Option::Some(value) = &self.sparse_types {
                builder.set_attr_type_list("sparse_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tdense {
                builder.set_attr_type_list("Tdense", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dense_shapes {
                builder.set_attr_shape_list("dense_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ParseExampleInst { op })
    }
}
impl ParseExampleInst {
    /// Returns a Vector of sparse_indices for 'sparse_indices' Output of this ParseExample operation.
    pub fn sparse_indices(&self) -> crate::Result<Vec<crate::Output>> {
        let mut Outputs = vec![];
        for i in 0..self.op.get_attr_int("Nsparse")? as i32 {
            Outputs.push(crate::Output {
                operation: self.op.clone(),
                index: i,
            });
        }
        Ok(Outputs)
    }
    /// Returns the 'sparse_values' Output of this 'ParseExample' operation.
    pub fn sparse_values(&self) -> crate::Result<crate::Output> {
        let dynamic_offset = (self.op.get_attr_int("Nsparse")? + 1) as i32;
        Ok(crate::Output {
            operation: self.op.clone(),
            index: dynamic_offset,
        })
    }
    /// Returns a Vector of sparse_shapes for 'sparse_shapes' Output of this ParseExample operation.
    pub fn sparse_shapes(&self) -> crate::Result<Vec<crate::Output>> {
        let dynamic_offset = (self.op.get_attr_int("Nsparse")? + 2) as i32;
        let mut Outputs = vec![];
        for i in dynamic_offset..dynamic_offset + self.op.get_attr_int("Nsparse")? as i32 {
            Outputs.push(crate::Output {
                operation: self.op.clone(),
                index: i,
            });
        }
        Ok(Outputs)
    }
    /// Returns the 'dense_values' Output of this 'ParseExample' operation.
    pub fn dense_values(&self) -> crate::Result<crate::Output> {
        let dynamic_offset = (2 * self.op.get_attr_int("Nsparse")? + 3) as i32;
        Ok(crate::Output {
            operation: self.op.clone(),
            index: dynamic_offset,
        })
    }
    /// Returns the 'serialized' Input of this 'ParseExample' operation.
    pub fn serialized(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'names' Input of this 'ParseExample' operation.
    pub fn names(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns a Vector of sparse_keys for 'sparse_keys' Input of this ParseExample operation.
    pub fn sparse_keys(&self) -> crate::Result<Vec<crate::Input>> {
        let mut Inputs = vec![];
        for i in 2..self.op.get_attr_int("Nsparse")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
    /// Returns a Vector of dense_keys for 'dense_keys' Input of this ParseExample operation.
    pub fn dense_keys(&self) -> crate::Result<Vec<crate::Input>> {
        let dynamic_offset = (self.op.get_attr_int("Nsparse")? + 3) as i32;
        let mut Inputs = vec![];
        for i in dynamic_offset..dynamic_offset + self.op.get_attr_int("Ndense")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
    /// Returns the 'dense_defaults' Input of this 'ParseExample' operation.
    pub fn dense_defaults(&self) -> crate::Result<crate::Input> {
        let dynamic_offset =
            (self.op.get_attr_int("Ndense")? + self.op.get_attr_int("Nsparse")? + 4) as i32;
        Ok(crate::Input {
            operation: &self.op,
            index: dynamic_offset,
        })
    }
}
impl From<ParseExampleInst> for crate::Operation {
    fn from(inst: ParseExampleInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ParseExample::new().build(serialized, names, sparse_keys, dense_keys, dense_defaults, scope)`.
pub fn parse_example<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
>(
    serialized: O0,
    names: O1,
    sparse_keys: O2,
    dense_keys: O3,
    dense_defaults: O4,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ParseExample::new().build(
        serialized,
        names,
        sparse_keys,
        dense_keys,
        dense_defaults,
        scope,
    )
}

/// Builder for the `ParseExampleDataset` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ParseExampleDataset {
    sparse_keys: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
    dense_keys: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
    sparse_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    Tdense: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    dense_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    sloppy: ::std::option::Option<bool>,
    ragged_keys: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
    ragged_value_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    ragged_split_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ParseExampleDataset' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ParseExampleDatasetInst {
    /// An instance of a fully built ParseExampleDataset Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ParseExampleDataset {
    /// Creates a new `ParseExampleDataset`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `sparse_keys` attribute.
    pub fn sparse_keys<ArgType: ::std::convert::Into<::std::vec::Vec<::std::string::String>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.sparse_keys = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `dense_keys` attribute.
    pub fn dense_keys<ArgType: ::std::convert::Into<::std::vec::Vec<::std::string::String>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.dense_keys = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `sparse_types` attribute.
    pub fn sparse_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.sparse_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tdense` attribute.
    pub fn Tdense<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tdense = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `dense_shapes` attribute.
    pub fn dense_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.dense_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `sloppy` attribute.
    pub fn sloppy<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.sloppy = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `ragged_keys` attribute.
    pub fn ragged_keys<ArgType: ::std::convert::Into<::std::vec::Vec<::std::string::String>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.ragged_keys = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `ragged_value_types` attribute.
    pub fn ragged_value_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.ragged_value_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `ragged_split_types` attribute.
    pub fn ragged_split_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.ragged_split_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ParseExampleDataset` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input_dataset: O0,
        num_parallel_calls: O1,
        dense_defaults: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            input_dataset.into(),
            num_parallel_calls.into(),
            dense_defaults.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        input_dataset: crate::Output,
        num_parallel_calls: crate::Output,
        dense_defaults: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ParseExampleDataset", |nd| {
            nd.add_input(input_dataset);
            nd.add_input(num_parallel_calls);
            nd.add_input(dense_defaults);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.sparse_keys {
                nd.set_attr_string_list("sparse_keys", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dense_keys {
                nd.set_attr_string_list("dense_keys", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.sparse_types {
                nd.set_attr_type_list("sparse_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tdense {
                nd.set_attr_type_list("Tdense", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dense_shapes {
                nd.set_attr_shape_list("dense_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.sloppy {
                nd.set_attr_bool("sloppy", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.ragged_keys {
                nd.set_attr_string_list("ragged_keys", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.ragged_value_types {
                nd.set_attr_type_list("ragged_value_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.ragged_split_types {
                nd.set_attr_type_list("ragged_split_types", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ParseExampleDataset' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_dataset: crate::Output,
        num_parallel_calls: crate::Output,
        dense_defaults: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ParseExampleDatasetInst> {
        let op = scope.new_operation("ParseExampleDataset", |builder| {
            builder.add_input(input_dataset);
            builder.add_input(num_parallel_calls);
            builder.add_input(dense_defaults);
            if let ::std::option::Option::Some(value) = &self.sparse_keys {
                builder.set_attr_string_list("sparse_keys", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dense_keys {
                builder.set_attr_string_list("dense_keys", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.sparse_types {
                builder.set_attr_type_list("sparse_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tdense {
                builder.set_attr_type_list("Tdense", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dense_shapes {
                builder.set_attr_shape_list("dense_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.sloppy {
                builder.set_attr_bool("sloppy", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.ragged_keys {
                builder.set_attr_string_list("ragged_keys", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.ragged_value_types {
                builder.set_attr_type_list("ragged_value_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.ragged_split_types {
                builder.set_attr_type_list("ragged_split_types", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ParseExampleDatasetInst { op })
    }
}
impl ParseExampleDatasetInst {
    /// Returns the 'handle' Output of this 'ParseExampleDataset' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_dataset' Input of this 'ParseExampleDataset' operation.
    pub fn input_dataset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'num_parallel_calls' Input of this 'ParseExampleDataset' operation.
    pub fn num_parallel_calls(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'dense_defaults' Input of this 'ParseExampleDataset' operation.
    pub fn dense_defaults(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<ParseExampleDatasetInst> for crate::Operation {
    fn from(inst: ParseExampleDatasetInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ParseExampleDataset::new().build(input_dataset, num_parallel_calls, dense_defaults, scope)`.
pub fn parse_example_dataset<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    input_dataset: O0,
    num_parallel_calls: O1,
    dense_defaults: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ParseExampleDataset::new().build(input_dataset, num_parallel_calls, dense_defaults, scope)
}

/// Builder for the `ParseExampleDatasetV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ParseExampleDatasetV2 {
    sparse_keys: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
    dense_keys: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
    sparse_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    Tdense: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    dense_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    deterministic: ::std::option::Option<::std::string::String>,
    ragged_keys: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
    ragged_value_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    ragged_split_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ParseExampleDatasetV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ParseExampleDatasetV2Inst {
    /// An instance of a fully built ParseExampleDatasetV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ParseExampleDatasetV2 {
    /// Creates a new `ParseExampleDatasetV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `sparse_keys` attribute.
    pub fn sparse_keys<ArgType: ::std::convert::Into<::std::vec::Vec<::std::string::String>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.sparse_keys = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `dense_keys` attribute.
    pub fn dense_keys<ArgType: ::std::convert::Into<::std::vec::Vec<::std::string::String>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.dense_keys = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `sparse_types` attribute.
    pub fn sparse_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.sparse_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tdense` attribute.
    pub fn Tdense<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tdense = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `dense_shapes` attribute.
    pub fn dense_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.dense_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `deterministic` attribute.
    pub fn deterministic<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.deterministic = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `ragged_keys` attribute.
    pub fn ragged_keys<ArgType: ::std::convert::Into<::std::vec::Vec<::std::string::String>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.ragged_keys = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `ragged_value_types` attribute.
    pub fn ragged_value_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.ragged_value_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `ragged_split_types` attribute.
    pub fn ragged_split_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.ragged_split_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ParseExampleDatasetV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input_dataset: O0,
        num_parallel_calls: O1,
        dense_defaults: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            input_dataset.into(),
            num_parallel_calls.into(),
            dense_defaults.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        input_dataset: crate::Output,
        num_parallel_calls: crate::Output,
        dense_defaults: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ParseExampleDatasetV2", |nd| {
            nd.add_input(input_dataset);
            nd.add_input(num_parallel_calls);
            nd.add_input(dense_defaults);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.sparse_keys {
                nd.set_attr_string_list("sparse_keys", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dense_keys {
                nd.set_attr_string_list("dense_keys", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.sparse_types {
                nd.set_attr_type_list("sparse_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tdense {
                nd.set_attr_type_list("Tdense", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dense_shapes {
                nd.set_attr_shape_list("dense_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.deterministic {
                nd.set_attr_string("deterministic", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.ragged_keys {
                nd.set_attr_string_list("ragged_keys", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.ragged_value_types {
                nd.set_attr_type_list("ragged_value_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.ragged_split_types {
                nd.set_attr_type_list("ragged_split_types", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ParseExampleDatasetV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_dataset: crate::Output,
        num_parallel_calls: crate::Output,
        dense_defaults: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ParseExampleDatasetV2Inst> {
        let op = scope.new_operation("ParseExampleDatasetV2", |builder| {
            builder.add_input(input_dataset);
            builder.add_input(num_parallel_calls);
            builder.add_input(dense_defaults);
            if let ::std::option::Option::Some(value) = &self.sparse_keys {
                builder.set_attr_string_list("sparse_keys", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dense_keys {
                builder.set_attr_string_list("dense_keys", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.sparse_types {
                builder.set_attr_type_list("sparse_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tdense {
                builder.set_attr_type_list("Tdense", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dense_shapes {
                builder.set_attr_shape_list("dense_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.deterministic {
                builder.set_attr_string("deterministic", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.ragged_keys {
                builder.set_attr_string_list("ragged_keys", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.ragged_value_types {
                builder.set_attr_type_list("ragged_value_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.ragged_split_types {
                builder.set_attr_type_list("ragged_split_types", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ParseExampleDatasetV2Inst { op })
    }
}
impl ParseExampleDatasetV2Inst {
    /// Returns the 'handle' Output of this 'ParseExampleDatasetV2' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_dataset' Input of this 'ParseExampleDatasetV2' operation.
    pub fn input_dataset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'num_parallel_calls' Input of this 'ParseExampleDatasetV2' operation.
    pub fn num_parallel_calls(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'dense_defaults' Input of this 'ParseExampleDatasetV2' operation.
    pub fn dense_defaults(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<ParseExampleDatasetV2Inst> for crate::Operation {
    fn from(inst: ParseExampleDatasetV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ParseExampleDatasetV2::new().build(input_dataset, num_parallel_calls, dense_defaults, scope)`.
pub fn parse_example_dataset_v2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    input_dataset: O0,
    num_parallel_calls: O1,
    dense_defaults: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ParseExampleDatasetV2::new().build(input_dataset, num_parallel_calls, dense_defaults, scope)
}

/// Builder for the `ParseExampleV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ParseExampleV2 {
    Tdense: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    num_sparse: ::std::option::Option<i64>,
    sparse_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    ragged_value_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    ragged_split_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    dense_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ParseExampleV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ParseExampleV2Inst {
    /// An instance of a fully built ParseExampleV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ParseExampleV2 {
    /// Creates a new `ParseExampleV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `Tdense` attribute.
    pub fn Tdense<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tdense = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `num_sparse` attribute.
    pub fn num_sparse<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.num_sparse = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `sparse_types` attribute.
    pub fn sparse_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.sparse_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `ragged_value_types` attribute.
    pub fn ragged_value_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.ragged_value_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `ragged_split_types` attribute.
    pub fn ragged_split_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.ragged_split_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `dense_shapes` attribute.
    pub fn dense_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.dense_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ParseExampleV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
    >(
        &self,
        serialized: O0,
        names: O1,
        sparse_keys: O2,
        dense_keys: O3,
        ragged_keys: O4,
        dense_defaults: O5,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            serialized.into(),
            names.into(),
            sparse_keys.into(),
            dense_keys.into(),
            ragged_keys.into(),
            dense_defaults.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        serialized: crate::Output,
        names: crate::Output,
        sparse_keys: crate::Output,
        dense_keys: crate::Output,
        ragged_keys: crate::Output,
        dense_defaults: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ParseExampleV2", |nd| {
            nd.add_input(serialized);
            nd.add_input(names);
            nd.add_input(sparse_keys);
            nd.add_input(dense_keys);
            nd.add_input(ragged_keys);
            nd.add_input(dense_defaults);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.Tdense {
                nd.set_attr_type_list("Tdense", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_sparse {
                nd.set_attr_int("num_sparse", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.sparse_types {
                nd.set_attr_type_list("sparse_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.ragged_value_types {
                nd.set_attr_type_list("ragged_value_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.ragged_split_types {
                nd.set_attr_type_list("ragged_split_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dense_shapes {
                nd.set_attr_shape_list("dense_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ParseExampleV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        serialized: crate::Output,
        names: crate::Output,
        sparse_keys: crate::Output,
        dense_keys: crate::Output,
        ragged_keys: crate::Output,
        dense_defaults: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ParseExampleV2Inst> {
        let op = scope.new_operation("ParseExampleV2", |builder| {
            builder.add_input(serialized);
            builder.add_input(names);
            builder.add_input(sparse_keys);
            builder.add_input(dense_keys);
            builder.add_input(ragged_keys);
            builder.add_input(dense_defaults);
            if let ::std::option::Option::Some(value) = &self.Tdense {
                builder.set_attr_type_list("Tdense", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_sparse {
                builder.set_attr_int("num_sparse", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.sparse_types {
                builder.set_attr_type_list("sparse_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.ragged_value_types {
                builder.set_attr_type_list("ragged_value_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.ragged_split_types {
                builder.set_attr_type_list("ragged_split_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dense_shapes {
                builder.set_attr_shape_list("dense_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ParseExampleV2Inst { op })
    }
}
impl ParseExampleV2Inst {
    /// Returns a Vector of sparse_indices for 'sparse_indices' Output of this ParseExampleV2 operation.
    pub fn sparse_indices(&self) -> crate::Result<Vec<crate::Output>> {
        let mut Outputs = vec![];
        for i in 0..self.op.get_attr_int("num_sparse")? as i32 {
            Outputs.push(crate::Output {
                operation: self.op.clone(),
                index: i,
            });
        }
        Ok(Outputs)
    }
    /// Returns the 'sparse_values' Output of this 'ParseExampleV2' operation.
    pub fn sparse_values(&self) -> crate::Result<crate::Output> {
        let dynamic_offset = (self.op.get_attr_int("num_sparse")? + 1) as i32;
        Ok(crate::Output {
            operation: self.op.clone(),
            index: dynamic_offset,
        })
    }
    /// Returns a Vector of sparse_shapes for 'sparse_shapes' Output of this ParseExampleV2 operation.
    pub fn sparse_shapes(&self) -> crate::Result<Vec<crate::Output>> {
        let dynamic_offset = (self.op.get_attr_int("num_sparse")? + 2) as i32;
        let mut Outputs = vec![];
        for i in dynamic_offset..dynamic_offset + self.op.get_attr_int("num_sparse")? as i32 {
            Outputs.push(crate::Output {
                operation: self.op.clone(),
                index: i,
            });
        }
        Ok(Outputs)
    }
    /// Returns the 'dense_values' Output of this 'ParseExampleV2' operation.
    pub fn dense_values(&self) -> crate::Result<crate::Output> {
        let dynamic_offset = (2 * self.op.get_attr_int("num_sparse")? + 3) as i32;
        Ok(crate::Output {
            operation: self.op.clone(),
            index: dynamic_offset,
        })
    }
    /// Returns the 'ragged_values' Output of this 'ParseExampleV2' operation.
    pub fn ragged_values(&self) -> crate::Result<crate::Output> {
        let dynamic_offset = (2 * self.op.get_attr_int("num_sparse")? + 4) as i32;
        Ok(crate::Output {
            operation: self.op.clone(),
            index: dynamic_offset,
        })
    }
    /// Returns the 'ragged_row_splits' Output of this 'ParseExampleV2' operation.
    pub fn ragged_row_splits(&self) -> crate::Result<crate::Output> {
        let dynamic_offset = (2 * self.op.get_attr_int("num_sparse")? + 5) as i32;
        Ok(crate::Output {
            operation: self.op.clone(),
            index: dynamic_offset,
        })
    }
    /// Returns the 'serialized' Input of this 'ParseExampleV2' operation.
    pub fn serialized(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'names' Input of this 'ParseExampleV2' operation.
    pub fn names(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'sparse_keys' Input of this 'ParseExampleV2' operation.
    pub fn sparse_keys(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'dense_keys' Input of this 'ParseExampleV2' operation.
    pub fn dense_keys(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'ragged_keys' Input of this 'ParseExampleV2' operation.
    pub fn ragged_keys(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
    /// Returns the 'dense_defaults' Input of this 'ParseExampleV2' operation.
    pub fn dense_defaults(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 5,
        }
    }
}
impl From<ParseExampleV2Inst> for crate::Operation {
    fn from(inst: ParseExampleV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ParseExampleV2::new().build(serialized, names, sparse_keys, dense_keys, ragged_keys, dense_defaults, scope)`.
pub fn parse_example_v2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
>(
    serialized: O0,
    names: O1,
    sparse_keys: O2,
    dense_keys: O3,
    ragged_keys: O4,
    dense_defaults: O5,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ParseExampleV2::new().build(
        serialized,
        names,
        sparse_keys,
        dense_keys,
        ragged_keys,
        dense_defaults,
        scope,
    )
}

/// Builder for the `ParseSequenceExample` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ParseSequenceExample {
    feature_list_dense_missing_assumed_empty:
        ::std::option::Option<::std::vec::Vec<::std::string::String>>,
    context_sparse_keys: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
    context_dense_keys: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
    feature_list_sparse_keys: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
    feature_list_dense_keys: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
    Ncontext_sparse: ::std::option::Option<i64>,
    Ncontext_dense: ::std::option::Option<i64>,
    Nfeature_list_sparse: ::std::option::Option<i64>,
    Nfeature_list_dense: ::std::option::Option<i64>,
    context_sparse_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    Tcontext_dense: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    feature_list_dense_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    context_dense_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    feature_list_sparse_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    feature_list_dense_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ParseSequenceExample' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ParseSequenceExampleInst {
    /// An instance of a fully built ParseSequenceExample Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ParseSequenceExample {
    /// Creates a new `ParseSequenceExample`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `feature_list_dense_missing_assumed_empty` attribute.
    pub fn feature_list_dense_missing_assumed_empty<
        ArgType: ::std::convert::Into<::std::vec::Vec<::std::string::String>>,
    >(
        mut self,
        value: ArgType,
    ) -> Self {
        self.feature_list_dense_missing_assumed_empty = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `context_sparse_keys` attribute.
    pub fn context_sparse_keys<
        ArgType: ::std::convert::Into<::std::vec::Vec<::std::string::String>>,
    >(
        mut self,
        value: ArgType,
    ) -> Self {
        self.context_sparse_keys = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `context_dense_keys` attribute.
    pub fn context_dense_keys<
        ArgType: ::std::convert::Into<::std::vec::Vec<::std::string::String>>,
    >(
        mut self,
        value: ArgType,
    ) -> Self {
        self.context_dense_keys = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `feature_list_sparse_keys` attribute.
    pub fn feature_list_sparse_keys<
        ArgType: ::std::convert::Into<::std::vec::Vec<::std::string::String>>,
    >(
        mut self,
        value: ArgType,
    ) -> Self {
        self.feature_list_sparse_keys = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `feature_list_dense_keys` attribute.
    pub fn feature_list_dense_keys<
        ArgType: ::std::convert::Into<::std::vec::Vec<::std::string::String>>,
    >(
        mut self,
        value: ArgType,
    ) -> Self {
        self.feature_list_dense_keys = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Ncontext_sparse` attribute.
    pub fn Ncontext_sparse<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.Ncontext_sparse = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Ncontext_dense` attribute.
    pub fn Ncontext_dense<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.Ncontext_dense = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Nfeature_list_sparse` attribute.
    pub fn Nfeature_list_sparse<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Nfeature_list_sparse = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Nfeature_list_dense` attribute.
    pub fn Nfeature_list_dense<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Nfeature_list_dense = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `context_sparse_types` attribute.
    pub fn context_sparse_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.context_sparse_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tcontext_dense` attribute.
    pub fn Tcontext_dense<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tcontext_dense = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `feature_list_dense_types` attribute.
    pub fn feature_list_dense_types<
        ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>,
    >(
        mut self,
        value: ArgType,
    ) -> Self {
        self.feature_list_dense_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `context_dense_shapes` attribute.
    pub fn context_dense_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.context_dense_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `feature_list_sparse_types` attribute.
    pub fn feature_list_sparse_types<
        ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>,
    >(
        mut self,
        value: ArgType,
    ) -> Self {
        self.feature_list_sparse_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `feature_list_dense_shapes` attribute.
    pub fn feature_list_dense_shapes<
        ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>,
    >(
        mut self,
        value: ArgType,
    ) -> Self {
        self.feature_list_dense_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ParseSequenceExample` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        serialized: O0,
        debug_name: O1,
        context_dense_defaults: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            serialized.into(),
            debug_name.into(),
            context_dense_defaults.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        serialized: crate::Output,
        debug_name: crate::Output,
        context_dense_defaults: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ParseSequenceExample", |nd| {
            nd.add_input(serialized);
            nd.add_input(debug_name);
            nd.add_input(context_dense_defaults);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) =
                &self.feature_list_dense_missing_assumed_empty
            {
                nd.set_attr_string_list("feature_list_dense_missing_assumed_empty", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.context_sparse_keys {
                nd.set_attr_string_list("context_sparse_keys", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.context_dense_keys {
                nd.set_attr_string_list("context_dense_keys", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.feature_list_sparse_keys {
                nd.set_attr_string_list("feature_list_sparse_keys", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.feature_list_dense_keys {
                nd.set_attr_string_list("feature_list_dense_keys", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Ncontext_sparse {
                nd.set_attr_int("Ncontext_sparse", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Ncontext_dense {
                nd.set_attr_int("Ncontext_dense", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Nfeature_list_sparse {
                nd.set_attr_int("Nfeature_list_sparse", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Nfeature_list_dense {
                nd.set_attr_int("Nfeature_list_dense", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.context_sparse_types {
                nd.set_attr_type_list("context_sparse_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tcontext_dense {
                nd.set_attr_type_list("Tcontext_dense", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.feature_list_dense_types {
                nd.set_attr_type_list("feature_list_dense_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.context_dense_shapes {
                nd.set_attr_shape_list("context_dense_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.feature_list_sparse_types {
                nd.set_attr_type_list("feature_list_sparse_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.feature_list_dense_shapes {
                nd.set_attr_shape_list("feature_list_dense_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ParseSequenceExample' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        serialized: crate::Output,
        debug_name: crate::Output,
        context_dense_defaults: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ParseSequenceExampleInst> {
        let op = scope.new_operation("ParseSequenceExample", |builder| {
            builder.add_input(serialized);
            builder.add_input(debug_name);
            builder.add_input(context_dense_defaults);
            if let ::std::option::Option::Some(value) =
                &self.feature_list_dense_missing_assumed_empty
            {
                builder.set_attr_string_list("feature_list_dense_missing_assumed_empty", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.context_sparse_keys {
                builder.set_attr_string_list("context_sparse_keys", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.context_dense_keys {
                builder.set_attr_string_list("context_dense_keys", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.feature_list_sparse_keys {
                builder.set_attr_string_list("feature_list_sparse_keys", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.feature_list_dense_keys {
                builder.set_attr_string_list("feature_list_dense_keys", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Ncontext_sparse {
                builder.set_attr_int("Ncontext_sparse", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Ncontext_dense {
                builder.set_attr_int("Ncontext_dense", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Nfeature_list_sparse {
                builder.set_attr_int("Nfeature_list_sparse", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Nfeature_list_dense {
                builder.set_attr_int("Nfeature_list_dense", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.context_sparse_types {
                builder.set_attr_type_list("context_sparse_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tcontext_dense {
                builder.set_attr_type_list("Tcontext_dense", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.feature_list_dense_types {
                builder.set_attr_type_list("feature_list_dense_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.context_dense_shapes {
                builder.set_attr_shape_list("context_dense_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.feature_list_sparse_types {
                builder.set_attr_type_list("feature_list_sparse_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.feature_list_dense_shapes {
                builder.set_attr_shape_list("feature_list_dense_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ParseSequenceExampleInst { op })
    }
}
impl ParseSequenceExampleInst {
    /// Returns a Vector of context_sparse_indices for 'context_sparse_indices' Output of this ParseSequenceExample operation.
    pub fn context_sparse_indices(&self) -> crate::Result<Vec<crate::Output>> {
        let mut Outputs = vec![];
        for i in 0..self.op.get_attr_int("Ncontext_sparse")? as i32 {
            Outputs.push(crate::Output {
                operation: self.op.clone(),
                index: i,
            });
        }
        Ok(Outputs)
    }
    /// Returns the 'context_sparse_values' Output of this 'ParseSequenceExample' operation.
    pub fn context_sparse_values(&self) -> crate::Result<crate::Output> {
        let dynamic_offset = (self.op.get_attr_int("Ncontext_sparse")? + 1) as i32;
        Ok(crate::Output {
            operation: self.op.clone(),
            index: dynamic_offset,
        })
    }
    /// Returns a Vector of context_sparse_shapes for 'context_sparse_shapes' Output of this ParseSequenceExample operation.
    pub fn context_sparse_shapes(&self) -> crate::Result<Vec<crate::Output>> {
        let dynamic_offset = (self.op.get_attr_int("Ncontext_sparse")? + 2) as i32;
        let mut Outputs = vec![];
        for i in dynamic_offset..dynamic_offset + self.op.get_attr_int("Ncontext_sparse")? as i32 {
            Outputs.push(crate::Output {
                operation: self.op.clone(),
                index: i,
            });
        }
        Ok(Outputs)
    }
    /// Returns the 'context_dense_values' Output of this 'ParseSequenceExample' operation.
    pub fn context_dense_values(&self) -> crate::Result<crate::Output> {
        let dynamic_offset = (2 * self.op.get_attr_int("Ncontext_sparse")? + 3) as i32;
        Ok(crate::Output {
            operation: self.op.clone(),
            index: dynamic_offset,
        })
    }
    /// Returns a Vector of feature_list_sparse_indices for 'feature_list_sparse_indices' Output of this ParseSequenceExample operation.
    pub fn feature_list_sparse_indices(&self) -> crate::Result<Vec<crate::Output>> {
        let dynamic_offset = (2 * self.op.get_attr_int("Ncontext_sparse")? + 4) as i32;
        let mut Outputs = vec![];
        for i in
            dynamic_offset..dynamic_offset + self.op.get_attr_int("Nfeature_list_sparse")? as i32
        {
            Outputs.push(crate::Output {
                operation: self.op.clone(),
                index: i,
            });
        }
        Ok(Outputs)
    }
    /// Returns the 'feature_list_sparse_values' Output of this 'ParseSequenceExample' operation.
    pub fn feature_list_sparse_values(&self) -> crate::Result<crate::Output> {
        let dynamic_offset = (self.op.get_attr_int("Nfeature_list_sparse")?
            + 2 * self.op.get_attr_int("Ncontext_sparse")?
            + 5) as i32;
        Ok(crate::Output {
            operation: self.op.clone(),
            index: dynamic_offset,
        })
    }
    /// Returns a Vector of feature_list_sparse_shapes for 'feature_list_sparse_shapes' Output of this ParseSequenceExample operation.
    pub fn feature_list_sparse_shapes(&self) -> crate::Result<Vec<crate::Output>> {
        let dynamic_offset = (2 * self.op.get_attr_int("Ncontext_sparse")?
            + self.op.get_attr_int("Nfeature_list_sparse")?
            + 6) as i32;
        let mut Outputs = vec![];
        for i in
            dynamic_offset..dynamic_offset + self.op.get_attr_int("Nfeature_list_sparse")? as i32
        {
            Outputs.push(crate::Output {
                operation: self.op.clone(),
                index: i,
            });
        }
        Ok(Outputs)
    }
    /// Returns the 'feature_list_dense_values' Output of this 'ParseSequenceExample' operation.
    pub fn feature_list_dense_values(&self) -> crate::Result<crate::Output> {
        let dynamic_offset = (2 * self.op.get_attr_int("Nfeature_list_sparse")?
            + 2 * self.op.get_attr_int("Ncontext_sparse")?
            + 7) as i32;
        Ok(crate::Output {
            operation: self.op.clone(),
            index: dynamic_offset,
        })
    }
    /// Returns a Vector of feature_list_dense_lengths for 'feature_list_dense_lengths' Output of this ParseSequenceExample operation.
    pub fn feature_list_dense_lengths(&self) -> crate::Result<Vec<crate::Output>> {
        let dynamic_offset = (2 * self.op.get_attr_int("Nfeature_list_sparse")?
            + 2 * self.op.get_attr_int("Ncontext_sparse")?
            + 8) as i32;
        let mut Outputs = vec![];
        for i in
            dynamic_offset..dynamic_offset + self.op.get_attr_int("Nfeature_list_dense")? as i32
        {
            Outputs.push(crate::Output {
                operation: self.op.clone(),
                index: i,
            });
        }
        Ok(Outputs)
    }
    /// Returns the 'serialized' Input of this 'ParseSequenceExample' operation.
    pub fn serialized(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'debug_name' Input of this 'ParseSequenceExample' operation.
    pub fn debug_name(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'context_dense_defaults' Input of this 'ParseSequenceExample' operation.
    pub fn context_dense_defaults(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<ParseSequenceExampleInst> for crate::Operation {
    fn from(inst: ParseSequenceExampleInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ParseSequenceExample::new().build(serialized, debug_name, context_dense_defaults, scope)`.
pub fn parse_sequence_example<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    serialized: O0,
    debug_name: O1,
    context_dense_defaults: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ParseSequenceExample::new().build(serialized, debug_name, context_dense_defaults, scope)
}

/// Builder for the `ParseSequenceExampleV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ParseSequenceExampleV2 {
    Ncontext_sparse: ::std::option::Option<i64>,
    Tcontext_dense: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    context_sparse_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    context_ragged_value_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    context_ragged_split_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    context_dense_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    Nfeature_list_sparse: ::std::option::Option<i64>,
    Nfeature_list_dense: ::std::option::Option<i64>,
    feature_list_dense_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    feature_list_sparse_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    feature_list_ragged_value_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    feature_list_ragged_split_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    feature_list_dense_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ParseSequenceExampleV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ParseSequenceExampleV2Inst {
    /// An instance of a fully built ParseSequenceExampleV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ParseSequenceExampleV2 {
    /// Creates a new `ParseSequenceExampleV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `Ncontext_sparse` attribute.
    pub fn Ncontext_sparse<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.Ncontext_sparse = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tcontext_dense` attribute.
    pub fn Tcontext_dense<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tcontext_dense = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `context_sparse_types` attribute.
    pub fn context_sparse_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.context_sparse_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `context_ragged_value_types` attribute.
    pub fn context_ragged_value_types<
        ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>,
    >(
        mut self,
        value: ArgType,
    ) -> Self {
        self.context_ragged_value_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `context_ragged_split_types` attribute.
    pub fn context_ragged_split_types<
        ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>,
    >(
        mut self,
        value: ArgType,
    ) -> Self {
        self.context_ragged_split_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `context_dense_shapes` attribute.
    pub fn context_dense_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.context_dense_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Nfeature_list_sparse` attribute.
    pub fn Nfeature_list_sparse<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Nfeature_list_sparse = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Nfeature_list_dense` attribute.
    pub fn Nfeature_list_dense<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Nfeature_list_dense = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `feature_list_dense_types` attribute.
    pub fn feature_list_dense_types<
        ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>,
    >(
        mut self,
        value: ArgType,
    ) -> Self {
        self.feature_list_dense_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `feature_list_sparse_types` attribute.
    pub fn feature_list_sparse_types<
        ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>,
    >(
        mut self,
        value: ArgType,
    ) -> Self {
        self.feature_list_sparse_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `feature_list_ragged_value_types` attribute.
    pub fn feature_list_ragged_value_types<
        ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>,
    >(
        mut self,
        value: ArgType,
    ) -> Self {
        self.feature_list_ragged_value_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `feature_list_ragged_split_types` attribute.
    pub fn feature_list_ragged_split_types<
        ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>,
    >(
        mut self,
        value: ArgType,
    ) -> Self {
        self.feature_list_ragged_split_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `feature_list_dense_shapes` attribute.
    pub fn feature_list_dense_shapes<
        ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>,
    >(
        mut self,
        value: ArgType,
    ) -> Self {
        self.feature_list_dense_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ParseSequenceExampleV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
        O6: ::std::convert::Into<crate::Output>,
        O7: ::std::convert::Into<crate::Output>,
        O8: ::std::convert::Into<crate::Output>,
        O9: ::std::convert::Into<crate::Output>,
    >(
        &self,
        serialized: O0,
        debug_name: O1,
        context_sparse_keys: O2,
        context_dense_keys: O3,
        context_ragged_keys: O4,
        feature_list_sparse_keys: O5,
        feature_list_dense_keys: O6,
        feature_list_ragged_keys: O7,
        feature_list_dense_missing_assumed_empty: O8,
        context_dense_defaults: O9,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            serialized.into(),
            debug_name.into(),
            context_sparse_keys.into(),
            context_dense_keys.into(),
            context_ragged_keys.into(),
            feature_list_sparse_keys.into(),
            feature_list_dense_keys.into(),
            feature_list_ragged_keys.into(),
            feature_list_dense_missing_assumed_empty.into(),
            context_dense_defaults.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        serialized: crate::Output,
        debug_name: crate::Output,
        context_sparse_keys: crate::Output,
        context_dense_keys: crate::Output,
        context_ragged_keys: crate::Output,
        feature_list_sparse_keys: crate::Output,
        feature_list_dense_keys: crate::Output,
        feature_list_ragged_keys: crate::Output,
        feature_list_dense_missing_assumed_empty: crate::Output,
        context_dense_defaults: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ParseSequenceExampleV2", |nd| {
            nd.add_input(serialized);
            nd.add_input(debug_name);
            nd.add_input(context_sparse_keys);
            nd.add_input(context_dense_keys);
            nd.add_input(context_ragged_keys);
            nd.add_input(feature_list_sparse_keys);
            nd.add_input(feature_list_dense_keys);
            nd.add_input(feature_list_ragged_keys);
            nd.add_input(feature_list_dense_missing_assumed_empty);
            nd.add_input(context_dense_defaults);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.Ncontext_sparse {
                nd.set_attr_int("Ncontext_sparse", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tcontext_dense {
                nd.set_attr_type_list("Tcontext_dense", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.context_sparse_types {
                nd.set_attr_type_list("context_sparse_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.context_ragged_value_types {
                nd.set_attr_type_list("context_ragged_value_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.context_ragged_split_types {
                nd.set_attr_type_list("context_ragged_split_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.context_dense_shapes {
                nd.set_attr_shape_list("context_dense_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Nfeature_list_sparse {
                nd.set_attr_int("Nfeature_list_sparse", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Nfeature_list_dense {
                nd.set_attr_int("Nfeature_list_dense", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.feature_list_dense_types {
                nd.set_attr_type_list("feature_list_dense_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.feature_list_sparse_types {
                nd.set_attr_type_list("feature_list_sparse_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.feature_list_ragged_value_types {
                nd.set_attr_type_list("feature_list_ragged_value_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.feature_list_ragged_split_types {
                nd.set_attr_type_list("feature_list_ragged_split_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.feature_list_dense_shapes {
                nd.set_attr_shape_list("feature_list_dense_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ParseSequenceExampleV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        serialized: crate::Output,
        debug_name: crate::Output,
        context_sparse_keys: crate::Output,
        context_dense_keys: crate::Output,
        context_ragged_keys: crate::Output,
        feature_list_sparse_keys: crate::Output,
        feature_list_dense_keys: crate::Output,
        feature_list_ragged_keys: crate::Output,
        feature_list_dense_missing_assumed_empty: crate::Output,
        context_dense_defaults: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ParseSequenceExampleV2Inst> {
        let op = scope.new_operation("ParseSequenceExampleV2", |builder| {
            builder.add_input(serialized);
            builder.add_input(debug_name);
            builder.add_input(context_sparse_keys);
            builder.add_input(context_dense_keys);
            builder.add_input(context_ragged_keys);
            builder.add_input(feature_list_sparse_keys);
            builder.add_input(feature_list_dense_keys);
            builder.add_input(feature_list_ragged_keys);
            builder.add_input(feature_list_dense_missing_assumed_empty);
            builder.add_input(context_dense_defaults);
            if let ::std::option::Option::Some(value) = &self.Ncontext_sparse {
                builder.set_attr_int("Ncontext_sparse", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tcontext_dense {
                builder.set_attr_type_list("Tcontext_dense", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.context_sparse_types {
                builder.set_attr_type_list("context_sparse_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.context_ragged_value_types {
                builder.set_attr_type_list("context_ragged_value_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.context_ragged_split_types {
                builder.set_attr_type_list("context_ragged_split_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.context_dense_shapes {
                builder.set_attr_shape_list("context_dense_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Nfeature_list_sparse {
                builder.set_attr_int("Nfeature_list_sparse", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Nfeature_list_dense {
                builder.set_attr_int("Nfeature_list_dense", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.feature_list_dense_types {
                builder.set_attr_type_list("feature_list_dense_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.feature_list_sparse_types {
                builder.set_attr_type_list("feature_list_sparse_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.feature_list_ragged_value_types {
                builder.set_attr_type_list("feature_list_ragged_value_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.feature_list_ragged_split_types {
                builder.set_attr_type_list("feature_list_ragged_split_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.feature_list_dense_shapes {
                builder.set_attr_shape_list("feature_list_dense_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ParseSequenceExampleV2Inst { op })
    }
}
impl ParseSequenceExampleV2Inst {
    /// Returns a Vector of context_sparse_indices for 'context_sparse_indices' Output of this ParseSequenceExampleV2 operation.
    pub fn context_sparse_indices(&self) -> crate::Result<Vec<crate::Output>> {
        let mut Outputs = vec![];
        for i in 0..self.op.get_attr_int("Ncontext_sparse")? as i32 {
            Outputs.push(crate::Output {
                operation: self.op.clone(),
                index: i,
            });
        }
        Ok(Outputs)
    }
    /// Returns the 'context_sparse_values' Output of this 'ParseSequenceExampleV2' operation.
    pub fn context_sparse_values(&self) -> crate::Result<crate::Output> {
        let dynamic_offset = (self.op.get_attr_int("Ncontext_sparse")? + 1) as i32;
        Ok(crate::Output {
            operation: self.op.clone(),
            index: dynamic_offset,
        })
    }
    /// Returns a Vector of context_sparse_shapes for 'context_sparse_shapes' Output of this ParseSequenceExampleV2 operation.
    pub fn context_sparse_shapes(&self) -> crate::Result<Vec<crate::Output>> {
        let dynamic_offset = (self.op.get_attr_int("Ncontext_sparse")? + 2) as i32;
        let mut Outputs = vec![];
        for i in dynamic_offset..dynamic_offset + self.op.get_attr_int("Ncontext_sparse")? as i32 {
            Outputs.push(crate::Output {
                operation: self.op.clone(),
                index: i,
            });
        }
        Ok(Outputs)
    }
    /// Returns the 'context_dense_values' Output of this 'ParseSequenceExampleV2' operation.
    pub fn context_dense_values(&self) -> crate::Result<crate::Output> {
        let dynamic_offset = (2 * self.op.get_attr_int("Ncontext_sparse")? + 3) as i32;
        Ok(crate::Output {
            operation: self.op.clone(),
            index: dynamic_offset,
        })
    }
    /// Returns the 'context_ragged_values' Output of this 'ParseSequenceExampleV2' operation.
    pub fn context_ragged_values(&self) -> crate::Result<crate::Output> {
        let dynamic_offset = (2 * self.op.get_attr_int("Ncontext_sparse")? + 4) as i32;
        Ok(crate::Output {
            operation: self.op.clone(),
            index: dynamic_offset,
        })
    }
    /// Returns the 'context_ragged_row_splits' Output of this 'ParseSequenceExampleV2' operation.
    pub fn context_ragged_row_splits(&self) -> crate::Result<crate::Output> {
        let dynamic_offset = (2 * self.op.get_attr_int("Ncontext_sparse")? + 5) as i32;
        Ok(crate::Output {
            operation: self.op.clone(),
            index: dynamic_offset,
        })
    }
    /// Returns a Vector of feature_list_sparse_indices for 'feature_list_sparse_indices' Output of this ParseSequenceExampleV2 operation.
    pub fn feature_list_sparse_indices(&self) -> crate::Result<Vec<crate::Output>> {
        let dynamic_offset = (2 * self.op.get_attr_int("Ncontext_sparse")? + 6) as i32;
        let mut Outputs = vec![];
        for i in
            dynamic_offset..dynamic_offset + self.op.get_attr_int("Nfeature_list_sparse")? as i32
        {
            Outputs.push(crate::Output {
                operation: self.op.clone(),
                index: i,
            });
        }
        Ok(Outputs)
    }
    /// Returns the 'feature_list_sparse_values' Output of this 'ParseSequenceExampleV2' operation.
    pub fn feature_list_sparse_values(&self) -> crate::Result<crate::Output> {
        let dynamic_offset = (self.op.get_attr_int("Nfeature_list_sparse")?
            + 2 * self.op.get_attr_int("Ncontext_sparse")?
            + 7) as i32;
        Ok(crate::Output {
            operation: self.op.clone(),
            index: dynamic_offset,
        })
    }
    /// Returns a Vector of feature_list_sparse_shapes for 'feature_list_sparse_shapes' Output of this ParseSequenceExampleV2 operation.
    pub fn feature_list_sparse_shapes(&self) -> crate::Result<Vec<crate::Output>> {
        let dynamic_offset = (2 * self.op.get_attr_int("Ncontext_sparse")?
            + self.op.get_attr_int("Nfeature_list_sparse")?
            + 8) as i32;
        let mut Outputs = vec![];
        for i in
            dynamic_offset..dynamic_offset + self.op.get_attr_int("Nfeature_list_sparse")? as i32
        {
            Outputs.push(crate::Output {
                operation: self.op.clone(),
                index: i,
            });
        }
        Ok(Outputs)
    }
    /// Returns the 'feature_list_dense_values' Output of this 'ParseSequenceExampleV2' operation.
    pub fn feature_list_dense_values(&self) -> crate::Result<crate::Output> {
        let dynamic_offset = (2 * self.op.get_attr_int("Ncontext_sparse")?
            + 2 * self.op.get_attr_int("Nfeature_list_sparse")?
            + 9) as i32;
        Ok(crate::Output {
            operation: self.op.clone(),
            index: dynamic_offset,
        })
    }
    /// Returns a Vector of feature_list_dense_lengths for 'feature_list_dense_lengths' Output of this ParseSequenceExampleV2 operation.
    pub fn feature_list_dense_lengths(&self) -> crate::Result<Vec<crate::Output>> {
        let dynamic_offset = (2 * self.op.get_attr_int("Nfeature_list_sparse")?
            + 2 * self.op.get_attr_int("Ncontext_sparse")?
            + 10) as i32;
        let mut Outputs = vec![];
        for i in
            dynamic_offset..dynamic_offset + self.op.get_attr_int("Nfeature_list_dense")? as i32
        {
            Outputs.push(crate::Output {
                operation: self.op.clone(),
                index: i,
            });
        }
        Ok(Outputs)
    }
    /// Returns the 'feature_list_ragged_values' Output of this 'ParseSequenceExampleV2' operation.
    pub fn feature_list_ragged_values(&self) -> crate::Result<crate::Output> {
        let dynamic_offset = (2 * self.op.get_attr_int("Ncontext_sparse")?
            + 2 * self.op.get_attr_int("Nfeature_list_sparse")?
            + self.op.get_attr_int("Nfeature_list_dense")?
            + 11) as i32;
        Ok(crate::Output {
            operation: self.op.clone(),
            index: dynamic_offset,
        })
    }
    /// Returns the 'feature_list_ragged_outer_splits' Output of this 'ParseSequenceExampleV2' operation.
    pub fn feature_list_ragged_outer_splits(&self) -> crate::Result<crate::Output> {
        let dynamic_offset = (2 * self.op.get_attr_int("Ncontext_sparse")?
            + 2 * self.op.get_attr_int("Nfeature_list_sparse")?
            + self.op.get_attr_int("Nfeature_list_dense")?
            + 12) as i32;
        Ok(crate::Output {
            operation: self.op.clone(),
            index: dynamic_offset,
        })
    }
    /// Returns the 'feature_list_ragged_inner_splits' Output of this 'ParseSequenceExampleV2' operation.
    pub fn feature_list_ragged_inner_splits(&self) -> crate::Result<crate::Output> {
        let dynamic_offset = (self.op.get_attr_int("Nfeature_list_dense")?
            + 2 * self.op.get_attr_int("Ncontext_sparse")?
            + 2 * self.op.get_attr_int("Nfeature_list_sparse")?
            + 13) as i32;
        Ok(crate::Output {
            operation: self.op.clone(),
            index: dynamic_offset,
        })
    }
    /// Returns the 'serialized' Input of this 'ParseSequenceExampleV2' operation.
    pub fn serialized(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'debug_name' Input of this 'ParseSequenceExampleV2' operation.
    pub fn debug_name(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'context_sparse_keys' Input of this 'ParseSequenceExampleV2' operation.
    pub fn context_sparse_keys(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'context_dense_keys' Input of this 'ParseSequenceExampleV2' operation.
    pub fn context_dense_keys(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'context_ragged_keys' Input of this 'ParseSequenceExampleV2' operation.
    pub fn context_ragged_keys(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
    /// Returns the 'feature_list_sparse_keys' Input of this 'ParseSequenceExampleV2' operation.
    pub fn feature_list_sparse_keys(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 5,
        }
    }
    /// Returns the 'feature_list_dense_keys' Input of this 'ParseSequenceExampleV2' operation.
    pub fn feature_list_dense_keys(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 6,
        }
    }
    /// Returns the 'feature_list_ragged_keys' Input of this 'ParseSequenceExampleV2' operation.
    pub fn feature_list_ragged_keys(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 7,
        }
    }
    /// Returns the 'feature_list_dense_missing_assumed_empty' Input of this 'ParseSequenceExampleV2' operation.
    pub fn feature_list_dense_missing_assumed_empty(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 8,
        }
    }
    /// Returns the 'context_dense_defaults' Input of this 'ParseSequenceExampleV2' operation.
    pub fn context_dense_defaults(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 9,
        }
    }
}
impl From<ParseSequenceExampleV2Inst> for crate::Operation {
    fn from(inst: ParseSequenceExampleV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ParseSequenceExampleV2::new().build(serialized, debug_name, context_sparse_keys, context_dense_keys, context_ragged_keys, feature_list_sparse_keys, feature_list_dense_keys, feature_list_ragged_keys, feature_list_dense_missing_assumed_empty, context_dense_defaults, scope)`.
pub fn parse_sequence_example_v2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
    O6: ::std::convert::Into<crate::Output>,
    O7: ::std::convert::Into<crate::Output>,
    O8: ::std::convert::Into<crate::Output>,
    O9: ::std::convert::Into<crate::Output>,
>(
    serialized: O0,
    debug_name: O1,
    context_sparse_keys: O2,
    context_dense_keys: O3,
    context_ragged_keys: O4,
    feature_list_sparse_keys: O5,
    feature_list_dense_keys: O6,
    feature_list_ragged_keys: O7,
    feature_list_dense_missing_assumed_empty: O8,
    context_dense_defaults: O9,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ParseSequenceExampleV2::new().build(
        serialized,
        debug_name,
        context_sparse_keys,
        context_dense_keys,
        context_ragged_keys,
        feature_list_sparse_keys,
        feature_list_dense_keys,
        feature_list_ragged_keys,
        feature_list_dense_missing_assumed_empty,
        context_dense_defaults,
        scope,
    )
}

/// Builder for the `ParseSingleExample` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ParseSingleExample {
    num_sparse: ::std::option::Option<i64>,
    sparse_keys: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
    dense_keys: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
    sparse_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    Tdense: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    dense_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ParseSingleExample' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ParseSingleExampleInst {
    /// An instance of a fully built ParseSingleExample Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ParseSingleExample {
    /// Creates a new `ParseSingleExample`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `num_sparse` attribute.
    pub fn num_sparse<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.num_sparse = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `sparse_keys` attribute.
    pub fn sparse_keys<ArgType: ::std::convert::Into<::std::vec::Vec<::std::string::String>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.sparse_keys = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `dense_keys` attribute.
    pub fn dense_keys<ArgType: ::std::convert::Into<::std::vec::Vec<::std::string::String>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.dense_keys = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `sparse_types` attribute.
    pub fn sparse_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.sparse_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tdense` attribute.
    pub fn Tdense<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tdense = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `dense_shapes` attribute.
    pub fn dense_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.dense_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ParseSingleExample` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        serialized: O0,
        dense_defaults: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(serialized.into(), dense_defaults.into(), scope)
    }
    fn build_impl(
        &self,
        serialized: crate::Output,
        dense_defaults: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ParseSingleExample", |nd| {
            nd.add_input(serialized);
            nd.add_input(dense_defaults);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.num_sparse {
                nd.set_attr_int("num_sparse", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.sparse_keys {
                nd.set_attr_string_list("sparse_keys", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dense_keys {
                nd.set_attr_string_list("dense_keys", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.sparse_types {
                nd.set_attr_type_list("sparse_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tdense {
                nd.set_attr_type_list("Tdense", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dense_shapes {
                nd.set_attr_shape_list("dense_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ParseSingleExample' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        serialized: crate::Output,
        dense_defaults: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ParseSingleExampleInst> {
        let op = scope.new_operation("ParseSingleExample", |builder| {
            builder.add_input(serialized);
            builder.add_input(dense_defaults);
            if let ::std::option::Option::Some(value) = &self.num_sparse {
                builder.set_attr_int("num_sparse", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.sparse_keys {
                builder.set_attr_string_list("sparse_keys", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dense_keys {
                builder.set_attr_string_list("dense_keys", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.sparse_types {
                builder.set_attr_type_list("sparse_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tdense {
                builder.set_attr_type_list("Tdense", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dense_shapes {
                builder.set_attr_shape_list("dense_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ParseSingleExampleInst { op })
    }
}
impl ParseSingleExampleInst {
    /// Returns a Vector of sparse_indices for 'sparse_indices' Output of this ParseSingleExample operation.
    pub fn sparse_indices(&self) -> crate::Result<Vec<crate::Output>> {
        let mut Outputs = vec![];
        for i in 0..self.op.get_attr_int("num_sparse")? as i32 {
            Outputs.push(crate::Output {
                operation: self.op.clone(),
                index: i,
            });
        }
        Ok(Outputs)
    }
    /// Returns the 'sparse_values' Output of this 'ParseSingleExample' operation.
    pub fn sparse_values(&self) -> crate::Result<crate::Output> {
        let dynamic_offset = (self.op.get_attr_int("num_sparse")? + 1) as i32;
        Ok(crate::Output {
            operation: self.op.clone(),
            index: dynamic_offset,
        })
    }
    /// Returns a Vector of sparse_shapes for 'sparse_shapes' Output of this ParseSingleExample operation.
    pub fn sparse_shapes(&self) -> crate::Result<Vec<crate::Output>> {
        let dynamic_offset = (self.op.get_attr_int("num_sparse")? + 2) as i32;
        let mut Outputs = vec![];
        for i in dynamic_offset..dynamic_offset + self.op.get_attr_int("num_sparse")? as i32 {
            Outputs.push(crate::Output {
                operation: self.op.clone(),
                index: i,
            });
        }
        Ok(Outputs)
    }
    /// Returns the 'dense_values' Output of this 'ParseSingleExample' operation.
    pub fn dense_values(&self) -> crate::Result<crate::Output> {
        let dynamic_offset = (2 * self.op.get_attr_int("num_sparse")? + 3) as i32;
        Ok(crate::Output {
            operation: self.op.clone(),
            index: dynamic_offset,
        })
    }
    /// Returns the 'serialized' Input of this 'ParseSingleExample' operation.
    pub fn serialized(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'dense_defaults' Input of this 'ParseSingleExample' operation.
    pub fn dense_defaults(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<ParseSingleExampleInst> for crate::Operation {
    fn from(inst: ParseSingleExampleInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ParseSingleExample::new().build(serialized, dense_defaults, scope)`.
pub fn parse_single_example<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    serialized: O0,
    dense_defaults: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ParseSingleExample::new().build(serialized, dense_defaults, scope)
}

/// Builder for the `ParseSingleSequenceExample` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ParseSingleSequenceExample {
    Ncontext_sparse: ::std::option::Option<i64>,
    Ncontext_dense: ::std::option::Option<i64>,
    Nfeature_list_sparse: ::std::option::Option<i64>,
    Nfeature_list_dense: ::std::option::Option<i64>,
    context_sparse_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    Tcontext_dense: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    feature_list_dense_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    context_dense_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    feature_list_sparse_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    feature_list_dense_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ParseSingleSequenceExample' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ParseSingleSequenceExampleInst {
    /// An instance of a fully built ParseSingleSequenceExample Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ParseSingleSequenceExample {
    /// Creates a new `ParseSingleSequenceExample`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `Ncontext_sparse` attribute.
    pub fn Ncontext_sparse<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.Ncontext_sparse = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Ncontext_dense` attribute.
    pub fn Ncontext_dense<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.Ncontext_dense = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Nfeature_list_sparse` attribute.
    pub fn Nfeature_list_sparse<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Nfeature_list_sparse = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Nfeature_list_dense` attribute.
    pub fn Nfeature_list_dense<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Nfeature_list_dense = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `context_sparse_types` attribute.
    pub fn context_sparse_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.context_sparse_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tcontext_dense` attribute.
    pub fn Tcontext_dense<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tcontext_dense = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `feature_list_dense_types` attribute.
    pub fn feature_list_dense_types<
        ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>,
    >(
        mut self,
        value: ArgType,
    ) -> Self {
        self.feature_list_dense_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `context_dense_shapes` attribute.
    pub fn context_dense_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.context_dense_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `feature_list_sparse_types` attribute.
    pub fn feature_list_sparse_types<
        ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>,
    >(
        mut self,
        value: ArgType,
    ) -> Self {
        self.feature_list_sparse_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `feature_list_dense_shapes` attribute.
    pub fn feature_list_dense_shapes<
        ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>,
    >(
        mut self,
        value: ArgType,
    ) -> Self {
        self.feature_list_dense_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ParseSingleSequenceExample` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
        O6: ::std::convert::Into<crate::Output>,
        O7: ::std::convert::Into<crate::Output>,
    >(
        &self,
        serialized: O0,
        feature_list_dense_missing_assumed_empty: O1,
        context_sparse_keys: O2,
        context_dense_keys: O3,
        feature_list_sparse_keys: O4,
        feature_list_dense_keys: O5,
        context_dense_defaults: O6,
        debug_name: O7,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            serialized.into(),
            feature_list_dense_missing_assumed_empty.into(),
            context_sparse_keys.into(),
            context_dense_keys.into(),
            feature_list_sparse_keys.into(),
            feature_list_dense_keys.into(),
            context_dense_defaults.into(),
            debug_name.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        serialized: crate::Output,
        feature_list_dense_missing_assumed_empty: crate::Output,
        context_sparse_keys: crate::Output,
        context_dense_keys: crate::Output,
        feature_list_sparse_keys: crate::Output,
        feature_list_dense_keys: crate::Output,
        context_dense_defaults: crate::Output,
        debug_name: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ParseSingleSequenceExample", |nd| {
            nd.add_input(serialized);
            nd.add_input(feature_list_dense_missing_assumed_empty);
            nd.add_input(context_sparse_keys);
            nd.add_input(context_dense_keys);
            nd.add_input(feature_list_sparse_keys);
            nd.add_input(feature_list_dense_keys);
            nd.add_input(context_dense_defaults);
            nd.add_input(debug_name);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.Ncontext_sparse {
                nd.set_attr_int("Ncontext_sparse", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Ncontext_dense {
                nd.set_attr_int("Ncontext_dense", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Nfeature_list_sparse {
                nd.set_attr_int("Nfeature_list_sparse", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Nfeature_list_dense {
                nd.set_attr_int("Nfeature_list_dense", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.context_sparse_types {
                nd.set_attr_type_list("context_sparse_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tcontext_dense {
                nd.set_attr_type_list("Tcontext_dense", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.feature_list_dense_types {
                nd.set_attr_type_list("feature_list_dense_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.context_dense_shapes {
                nd.set_attr_shape_list("context_dense_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.feature_list_sparse_types {
                nd.set_attr_type_list("feature_list_sparse_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.feature_list_dense_shapes {
                nd.set_attr_shape_list("feature_list_dense_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ParseSingleSequenceExample' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        serialized: crate::Output,
        feature_list_dense_missing_assumed_empty: crate::Output,
        context_sparse_keys: Vec<crate::Output>,
        context_dense_keys: Vec<crate::Output>,
        feature_list_sparse_keys: Vec<crate::Output>,
        feature_list_dense_keys: Vec<crate::Output>,
        context_dense_defaults: crate::Output,
        debug_name: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ParseSingleSequenceExampleInst> {
        let op = scope.new_operation("ParseSingleSequenceExample", |builder| {
            builder.add_input(serialized);
            builder.add_input(feature_list_dense_missing_assumed_empty);
            builder.add_input_list(&context_sparse_keys);
            builder.add_input_list(&context_dense_keys);
            builder.add_input_list(&feature_list_sparse_keys);
            builder.add_input_list(&feature_list_dense_keys);
            builder.add_input(context_dense_defaults);
            builder.add_input(debug_name);
            builder.set_attr_int("Ncontext_sparse", context_sparse_keys.clone().len() as i64)?;
            builder.set_attr_int("Ncontext_dense", context_dense_keys.clone().len() as i64)?;
            builder.set_attr_int(
                "Nfeature_list_sparse",
                feature_list_sparse_keys.clone().len() as i64,
            )?;
            builder.set_attr_int(
                "Nfeature_list_dense",
                feature_list_dense_keys.clone().len() as i64,
            )?;
            if let ::std::option::Option::Some(value) = &self.context_sparse_types {
                builder.set_attr_type_list("context_sparse_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tcontext_dense {
                builder.set_attr_type_list("Tcontext_dense", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.feature_list_dense_types {
                builder.set_attr_type_list("feature_list_dense_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.context_dense_shapes {
                builder.set_attr_shape_list("context_dense_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.feature_list_sparse_types {
                builder.set_attr_type_list("feature_list_sparse_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.feature_list_dense_shapes {
                builder.set_attr_shape_list("feature_list_dense_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ParseSingleSequenceExampleInst { op })
    }
}
impl ParseSingleSequenceExampleInst {
    /// Returns a Vector of context_sparse_indices for 'context_sparse_indices' Output of this ParseSingleSequenceExample operation.
    pub fn context_sparse_indices(&self) -> crate::Result<Vec<crate::Output>> {
        let mut Outputs = vec![];
        for i in 0..self.op.get_attr_int("Ncontext_sparse")? as i32 {
            Outputs.push(crate::Output {
                operation: self.op.clone(),
                index: i,
            });
        }
        Ok(Outputs)
    }
    /// Returns the 'context_sparse_values' Output of this 'ParseSingleSequenceExample' operation.
    pub fn context_sparse_values(&self) -> crate::Result<crate::Output> {
        let dynamic_offset = (self.op.get_attr_int("Ncontext_sparse")? + 1) as i32;
        Ok(crate::Output {
            operation: self.op.clone(),
            index: dynamic_offset,
        })
    }
    /// Returns a Vector of context_sparse_shapes for 'context_sparse_shapes' Output of this ParseSingleSequenceExample operation.
    pub fn context_sparse_shapes(&self) -> crate::Result<Vec<crate::Output>> {
        let dynamic_offset = (self.op.get_attr_int("Ncontext_sparse")? + 2) as i32;
        let mut Outputs = vec![];
        for i in dynamic_offset..dynamic_offset + self.op.get_attr_int("Ncontext_sparse")? as i32 {
            Outputs.push(crate::Output {
                operation: self.op.clone(),
                index: i,
            });
        }
        Ok(Outputs)
    }
    /// Returns the 'context_dense_values' Output of this 'ParseSingleSequenceExample' operation.
    pub fn context_dense_values(&self) -> crate::Result<crate::Output> {
        let dynamic_offset = (2 * self.op.get_attr_int("Ncontext_sparse")? + 3) as i32;
        Ok(crate::Output {
            operation: self.op.clone(),
            index: dynamic_offset,
        })
    }
    /// Returns a Vector of feature_list_sparse_indices for 'feature_list_sparse_indices' Output of this ParseSingleSequenceExample operation.
    pub fn feature_list_sparse_indices(&self) -> crate::Result<Vec<crate::Output>> {
        let dynamic_offset = (2 * self.op.get_attr_int("Ncontext_sparse")? + 4) as i32;
        let mut Outputs = vec![];
        for i in
            dynamic_offset..dynamic_offset + self.op.get_attr_int("Nfeature_list_sparse")? as i32
        {
            Outputs.push(crate::Output {
                operation: self.op.clone(),
                index: i,
            });
        }
        Ok(Outputs)
    }
    /// Returns the 'feature_list_sparse_values' Output of this 'ParseSingleSequenceExample' operation.
    pub fn feature_list_sparse_values(&self) -> crate::Result<crate::Output> {
        let dynamic_offset = (2 * self.op.get_attr_int("Ncontext_sparse")?
            + self.op.get_attr_int("Nfeature_list_sparse")?
            + 5) as i32;
        Ok(crate::Output {
            operation: self.op.clone(),
            index: dynamic_offset,
        })
    }
    /// Returns a Vector of feature_list_sparse_shapes for 'feature_list_sparse_shapes' Output of this ParseSingleSequenceExample operation.
    pub fn feature_list_sparse_shapes(&self) -> crate::Result<Vec<crate::Output>> {
        let dynamic_offset = (2 * self.op.get_attr_int("Ncontext_sparse")?
            + self.op.get_attr_int("Nfeature_list_sparse")?
            + 6) as i32;
        let mut Outputs = vec![];
        for i in
            dynamic_offset..dynamic_offset + self.op.get_attr_int("Nfeature_list_sparse")? as i32
        {
            Outputs.push(crate::Output {
                operation: self.op.clone(),
                index: i,
            });
        }
        Ok(Outputs)
    }
    /// Returns the 'feature_list_dense_values' Output of this 'ParseSingleSequenceExample' operation.
    pub fn feature_list_dense_values(&self) -> crate::Result<crate::Output> {
        let dynamic_offset = (2 * self.op.get_attr_int("Ncontext_sparse")?
            + 2 * self.op.get_attr_int("Nfeature_list_sparse")?
            + 7) as i32;
        Ok(crate::Output {
            operation: self.op.clone(),
            index: dynamic_offset,
        })
    }
    /// Returns the 'serialized' Input of this 'ParseSingleSequenceExample' operation.
    pub fn serialized(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'feature_list_dense_missing_assumed_empty' Input of this 'ParseSingleSequenceExample' operation.
    pub fn feature_list_dense_missing_assumed_empty(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns a Vector of context_sparse_keys for 'context_sparse_keys' Input of this ParseSingleSequenceExample operation.
    pub fn context_sparse_keys(&self) -> crate::Result<Vec<crate::Input>> {
        let mut Inputs = vec![];
        for i in 2..self.op.get_attr_int("Ncontext_sparse")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
    /// Returns a Vector of context_dense_keys for 'context_dense_keys' Input of this ParseSingleSequenceExample operation.
    pub fn context_dense_keys(&self) -> crate::Result<Vec<crate::Input>> {
        let dynamic_offset = (self.op.get_attr_int("Ncontext_sparse")? + 3) as i32;
        let mut Inputs = vec![];
        for i in dynamic_offset..dynamic_offset + self.op.get_attr_int("Ncontext_dense")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
    /// Returns a Vector of feature_list_sparse_keys for 'feature_list_sparse_keys' Input of this ParseSingleSequenceExample operation.
    pub fn feature_list_sparse_keys(&self) -> crate::Result<Vec<crate::Input>> {
        let dynamic_offset = (self.op.get_attr_int("Ncontext_dense")?
            + self.op.get_attr_int("Ncontext_sparse")?
            + 4) as i32;
        let mut Inputs = vec![];
        for i in
            dynamic_offset..dynamic_offset + self.op.get_attr_int("Nfeature_list_sparse")? as i32
        {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
    /// Returns a Vector of feature_list_dense_keys for 'feature_list_dense_keys' Input of this ParseSingleSequenceExample operation.
    pub fn feature_list_dense_keys(&self) -> crate::Result<Vec<crate::Input>> {
        let dynamic_offset = (self.op.get_attr_int("Nfeature_list_sparse")?
            + self.op.get_attr_int("Ncontext_sparse")?
            + self.op.get_attr_int("Ncontext_dense")?
            + 5) as i32;
        let mut Inputs = vec![];
        for i in
            dynamic_offset..dynamic_offset + self.op.get_attr_int("Nfeature_list_dense")? as i32
        {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
    /// Returns the 'context_dense_defaults' Input of this 'ParseSingleSequenceExample' operation.
    pub fn context_dense_defaults(&self) -> crate::Result<crate::Input> {
        let dynamic_offset = (self.op.get_attr_int("Nfeature_list_sparse")?
            + self.op.get_attr_int("Ncontext_dense")?
            + self.op.get_attr_int("Nfeature_list_dense")?
            + self.op.get_attr_int("Ncontext_sparse")?
            + 6) as i32;
        Ok(crate::Input {
            operation: &self.op,
            index: dynamic_offset,
        })
    }
    /// Returns the 'debug_name' Input of this 'ParseSingleSequenceExample' operation.
    pub fn debug_name(&self) -> crate::Result<crate::Input> {
        let dynamic_offset = (self.op.get_attr_int("Ncontext_dense")?
            + self.op.get_attr_int("Ncontext_sparse")?
            + self.op.get_attr_int("Nfeature_list_dense")?
            + self.op.get_attr_int("Nfeature_list_sparse")?
            + 7) as i32;
        Ok(crate::Input {
            operation: &self.op,
            index: dynamic_offset,
        })
    }
}
impl From<ParseSingleSequenceExampleInst> for crate::Operation {
    fn from(inst: ParseSingleSequenceExampleInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ParseSingleSequenceExample::new().build(serialized, feature_list_dense_missing_assumed_empty, context_sparse_keys, context_dense_keys, feature_list_sparse_keys, feature_list_dense_keys, context_dense_defaults, debug_name, scope)`.
pub fn parse_single_sequence_example<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
    O6: ::std::convert::Into<crate::Output>,
    O7: ::std::convert::Into<crate::Output>,
>(
    serialized: O0,
    feature_list_dense_missing_assumed_empty: O1,
    context_sparse_keys: O2,
    context_dense_keys: O3,
    feature_list_sparse_keys: O4,
    feature_list_dense_keys: O5,
    context_dense_defaults: O6,
    debug_name: O7,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ParseSingleSequenceExample::new().build(
        serialized,
        feature_list_dense_missing_assumed_empty,
        context_sparse_keys,
        context_dense_keys,
        feature_list_sparse_keys,
        feature_list_dense_keys,
        context_dense_defaults,
        debug_name,
        scope,
    )
}

/// Builder for the `ParseTensor` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ParseTensor {
    out_type: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ParseTensor' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ParseTensorInst {
    /// An instance of a fully built ParseTensor Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ParseTensor {
    /// Creates a new `ParseTensor`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `out_type` attribute.
    pub fn out_type<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.out_type = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ParseTensor` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        serialized: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(serialized.into(), scope)
    }
    fn build_impl(
        &self,
        serialized: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ParseTensor", |nd| {
            nd.add_input(serialized);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.out_type {
                nd.set_attr_type("out_type", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ParseTensor' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        serialized: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ParseTensorInst> {
        let op = scope.new_operation("ParseTensor", |builder| {
            builder.add_input(serialized);
            if let ::std::option::Option::Some(value) = &self.out_type {
                builder.set_attr_type("out_type", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ParseTensorInst { op })
    }
}
impl ParseTensorInst {
    /// Returns the 'output' Output of this 'ParseTensor' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'serialized' Input of this 'ParseTensor' operation.
    pub fn serialized(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<ParseTensorInst> for crate::Operation {
    fn from(inst: ParseTensorInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ParseTensor::new().build(serialized, scope)`.
pub fn parse_tensor<O0: ::std::convert::Into<crate::Output>>(
    serialized: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ParseTensor::new().build(serialized, scope)
}

/// Builder for the `PartitionedCall` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct PartitionedCall {
    Tin: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    Tout: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    f: ::std::option::Option<::std::string::String>,
    config: ::std::option::Option<::std::string::String>,
    config_proto: ::std::option::Option<::std::string::String>,
    executor_type: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'PartitionedCall' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct PartitionedCallInst {
    /// An instance of a fully built PartitionedCall Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl PartitionedCall {
    /// Creates a new `PartitionedCall`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `Tin` attribute.
    pub fn Tin<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tin = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tout` attribute.
    pub fn Tout<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tout = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `f` attribute.
    pub fn f<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.f = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `config` attribute.
    pub fn config<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.config = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `config_proto` attribute.
    pub fn config_proto<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.config_proto = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `executor_type` attribute.
    pub fn executor_type<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.executor_type = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `PartitionedCall` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        args: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(args.into(), scope)
    }
    fn build_impl(
        &self,
        args: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("PartitionedCall", |nd| {
            nd.add_input(args);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.Tin {
                nd.set_attr_type_list("Tin", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tout {
                nd.set_attr_type_list("Tout", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.f {
                nd.set_attr_string("f", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.config {
                nd.set_attr_string("config", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.config_proto {
                nd.set_attr_string("config_proto", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.executor_type {
                nd.set_attr_string("executor_type", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'PartitionedCall' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        args: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<PartitionedCallInst> {
        let op = scope.new_operation("PartitionedCall", |builder| {
            builder.add_input(args);
            if let ::std::option::Option::Some(value) = &self.Tin {
                builder.set_attr_type_list("Tin", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tout {
                builder.set_attr_type_list("Tout", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.f {
                builder.set_attr_string("f", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.config {
                builder.set_attr_string("config", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.config_proto {
                builder.set_attr_string("config_proto", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.executor_type {
                builder.set_attr_string("executor_type", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(PartitionedCallInst { op })
    }
}
impl PartitionedCallInst {
    /// Returns the 'output' Output of this 'PartitionedCall' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'args' Input of this 'PartitionedCall' operation.
    pub fn args(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<PartitionedCallInst> for crate::Operation {
    fn from(inst: PartitionedCallInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `PartitionedCall::new().build(args, scope)`.
pub fn partitioned_call<O0: ::std::convert::Into<crate::Output>>(
    args: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    PartitionedCall::new().build(args, scope)
}

/// Builder for the `Placeholder` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Placeholder {
    dtype: ::std::option::Option<crate::DataType>,
    shape: ::std::option::Option<crate::Shape>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Placeholder' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct PlaceholderInst {
    /// An instance of a fully built Placeholder Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Placeholder {
    /// Creates a new `Placeholder`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `dtype` attribute.
    pub fn dtype<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shape` attribute.
    pub fn shape<ArgType: ::std::convert::Into<crate::Shape>>(mut self, value: ArgType) -> Self {
        self.shape = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Placeholder` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("Placeholder", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                nd.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shape {
                nd.set_attr_shape("shape", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Placeholder' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(&self, scope: &mut crate::Scope) -> crate::Result<PlaceholderInst> {
        let op = scope.new_operation("Placeholder", |builder| {
            if let ::std::option::Option::Some(value) = &self.dtype {
                builder.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shape {
                builder.set_attr_shape("shape", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(PlaceholderInst { op })
    }
}
impl PlaceholderInst {
    /// Returns the 'output' Output of this 'Placeholder' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
}
impl From<PlaceholderInst> for crate::Operation {
    fn from(inst: PlaceholderInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Placeholder::new().build(scope)`.
pub fn placeholder(scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
    Placeholder::new().build(scope)
}

/// Builder for the `PlaceholderV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct PlaceholderV2 {
    dtype: ::std::option::Option<crate::DataType>,
    shape: ::std::option::Option<crate::Shape>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'PlaceholderV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct PlaceholderV2Inst {
    /// An instance of a fully built PlaceholderV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl PlaceholderV2 {
    /// Creates a new `PlaceholderV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `dtype` attribute.
    pub fn dtype<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shape` attribute.
    pub fn shape<ArgType: ::std::convert::Into<crate::Shape>>(mut self, value: ArgType) -> Self {
        self.shape = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `PlaceholderV2` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("PlaceholderV2", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                nd.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shape {
                nd.set_attr_shape("shape", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'PlaceholderV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(&self, scope: &mut crate::Scope) -> crate::Result<PlaceholderV2Inst> {
        let op = scope.new_operation("PlaceholderV2", |builder| {
            if let ::std::option::Option::Some(value) = &self.dtype {
                builder.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shape {
                builder.set_attr_shape("shape", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(PlaceholderV2Inst { op })
    }
}
impl PlaceholderV2Inst {
    /// Returns the 'output' Output of this 'PlaceholderV2' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
}
impl From<PlaceholderV2Inst> for crate::Operation {
    fn from(inst: PlaceholderV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `PlaceholderV2::new().build(scope)`.
pub fn placeholder_v2(scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
    PlaceholderV2::new().build(scope)
}

/// Builder for the `PlaceholderWithDefault` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct PlaceholderWithDefault {
    dtype: ::std::option::Option<crate::DataType>,
    shape: ::std::option::Option<crate::Shape>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'PlaceholderWithDefault' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct PlaceholderWithDefaultInst {
    /// An instance of a fully built PlaceholderWithDefault Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl PlaceholderWithDefault {
    /// Creates a new `PlaceholderWithDefault`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `dtype` attribute.
    pub fn dtype<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shape` attribute.
    pub fn shape<ArgType: ::std::convert::Into<crate::Shape>>(mut self, value: ArgType) -> Self {
        self.shape = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `PlaceholderWithDefault` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("PlaceholderWithDefault", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                nd.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shape {
                nd.set_attr_shape("shape", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'PlaceholderWithDefault' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<PlaceholderWithDefaultInst> {
        let op = scope.new_operation("PlaceholderWithDefault", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.dtype {
                builder.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shape {
                builder.set_attr_shape("shape", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(PlaceholderWithDefaultInst { op })
    }
}
impl PlaceholderWithDefaultInst {
    /// Returns the 'output' Output of this 'PlaceholderWithDefault' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'PlaceholderWithDefault' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<PlaceholderWithDefaultInst> for crate::Operation {
    fn from(inst: PlaceholderWithDefaultInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `PlaceholderWithDefault::new().build(input, scope)`.
pub fn placeholder_with_default<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    PlaceholderWithDefault::new().build(input, scope)
}

/// Builder for the `Polygamma` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Polygamma {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Polygamma' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct PolygammaInst {
    /// An instance of a fully built Polygamma Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Polygamma {
    /// Creates a new `Polygamma`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Polygamma` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        a: O0,
        x: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(a.into(), x.into(), scope)
    }
    fn build_impl(
        &self,
        a: crate::Output,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Polygamma", |nd| {
            nd.add_input(a);
            nd.add_input(x);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Polygamma' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        a: crate::Output,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<PolygammaInst> {
        let op = scope.new_operation("Polygamma", |builder| {
            builder.add_input(a);
            builder.add_input(x);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(PolygammaInst { op })
    }
}
impl PolygammaInst {
    /// Returns the 'z' Output of this 'Polygamma' operation.
    pub fn z(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'a' Input of this 'Polygamma' operation.
    pub fn a(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'Polygamma' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<PolygammaInst> for crate::Operation {
    fn from(inst: PolygammaInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Polygamma::new().build(a, x, scope)`.
pub fn polygamma<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    a: O0,
    x: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Polygamma::new().build(a, x, scope)
}

/// Builder for the `PopulationCount` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct PopulationCount {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'PopulationCount' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct PopulationCountInst {
    /// An instance of a fully built PopulationCount Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl PopulationCount {
    /// Creates a new `PopulationCount`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `PopulationCount` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        x: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("PopulationCount", |nd| {
            nd.add_input(x);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'PopulationCount' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<PopulationCountInst> {
        let op = scope.new_operation("PopulationCount", |builder| {
            builder.add_input(x);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(PopulationCountInst { op })
    }
}
impl PopulationCountInst {
    /// Returns the 'y' Output of this 'PopulationCount' operation.
    pub fn y(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'PopulationCount' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<PopulationCountInst> for crate::Operation {
    fn from(inst: PopulationCountInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `PopulationCount::new().build(x, scope)`.
pub fn population_count<O0: ::std::convert::Into<crate::Output>>(
    x: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    PopulationCount::new().build(x, scope)
}

/// Builder for the `Pow` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Pow {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Pow' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct PowInst {
    /// An instance of a fully built Pow Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Pow {
    /// Creates a new `Pow`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Pow` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        x: O0,
        y: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), y.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        y: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Pow", |nd| {
            nd.add_input(x);
            nd.add_input(y);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Pow' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        y: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<PowInst> {
        let op = scope.new_operation("Pow", |builder| {
            builder.add_input(x);
            builder.add_input(y);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(PowInst { op })
    }
}
impl PowInst {
    /// Returns the 'z' Output of this 'Pow' operation.
    pub fn z(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'Pow' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'y' Input of this 'Pow' operation.
    pub fn y(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<PowInst> for crate::Operation {
    fn from(inst: PowInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Pow::new().build(x, y, scope)`.
pub fn pow<O0: ::std::convert::Into<crate::Output>, O1: ::std::convert::Into<crate::Output>>(
    x: O0,
    y: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Pow::new().build(x, y, scope)
}

/// Builder for the `PrefetchDataset` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct PrefetchDataset {
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    slack_period: ::std::option::Option<i64>,
    legacy_autotune: ::std::option::Option<bool>,
    buffer_size_min: ::std::option::Option<i64>,
    metadata: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'PrefetchDataset' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct PrefetchDatasetInst {
    /// An instance of a fully built PrefetchDataset Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl PrefetchDataset {
    /// Creates a new `PrefetchDataset`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `slack_period` attribute.
    pub fn slack_period<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.slack_period = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `legacy_autotune` attribute.
    pub fn legacy_autotune<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.legacy_autotune = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `buffer_size_min` attribute.
    pub fn buffer_size_min<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.buffer_size_min = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `metadata` attribute.
    pub fn metadata<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.metadata = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `PrefetchDataset` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input_dataset: O0,
        buffer_size: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input_dataset.into(), buffer_size.into(), scope)
    }
    fn build_impl(
        &self,
        input_dataset: crate::Output,
        buffer_size: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("PrefetchDataset", |nd| {
            nd.add_input(input_dataset);
            nd.add_input(buffer_size);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.slack_period {
                nd.set_attr_int("slack_period", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.legacy_autotune {
                nd.set_attr_bool("legacy_autotune", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.buffer_size_min {
                nd.set_attr_int("buffer_size_min", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.metadata {
                nd.set_attr_string("metadata", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'PrefetchDataset' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_dataset: crate::Output,
        buffer_size: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<PrefetchDatasetInst> {
        let op = scope.new_operation("PrefetchDataset", |builder| {
            builder.add_input(input_dataset);
            builder.add_input(buffer_size);
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.slack_period {
                builder.set_attr_int("slack_period", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.legacy_autotune {
                builder.set_attr_bool("legacy_autotune", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.buffer_size_min {
                builder.set_attr_int("buffer_size_min", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.metadata {
                builder.set_attr_string("metadata", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(PrefetchDatasetInst { op })
    }
}
impl PrefetchDatasetInst {
    /// Returns the 'handle' Output of this 'PrefetchDataset' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_dataset' Input of this 'PrefetchDataset' operation.
    pub fn input_dataset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'buffer_size' Input of this 'PrefetchDataset' operation.
    pub fn buffer_size(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<PrefetchDatasetInst> for crate::Operation {
    fn from(inst: PrefetchDatasetInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `PrefetchDataset::new().build(input_dataset, buffer_size, scope)`.
pub fn prefetch_dataset<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    input_dataset: O0,
    buffer_size: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    PrefetchDataset::new().build(input_dataset, buffer_size, scope)
}

/// Builder for the `Prelinearize` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Prelinearize {
    dtype: ::std::option::Option<crate::DataType>,
    shape: ::std::option::Option<crate::Shape>,
    layout: ::std::option::Option<::std::vec::Vec<i64>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Prelinearize' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct PrelinearizeInst {
    /// An instance of a fully built Prelinearize Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Prelinearize {
    /// Creates a new `Prelinearize`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `dtype` attribute.
    pub fn dtype<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shape` attribute.
    pub fn shape<ArgType: ::std::convert::Into<crate::Shape>>(mut self, value: ArgType) -> Self {
        self.shape = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `layout` attribute.
    pub fn layout<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.layout = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Prelinearize` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Prelinearize", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                nd.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shape {
                nd.set_attr_shape("shape", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.layout {
                nd.set_attr_int_list("layout", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Prelinearize' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<PrelinearizeInst> {
        let op = scope.new_operation("Prelinearize", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.dtype {
                builder.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shape {
                builder.set_attr_shape("shape", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.layout {
                builder.set_attr_int_list("layout", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(PrelinearizeInst { op })
    }
}
impl PrelinearizeInst {
    /// Returns the 'output' Output of this 'Prelinearize' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'Prelinearize' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<PrelinearizeInst> for crate::Operation {
    fn from(inst: PrelinearizeInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Prelinearize::new().build(input, scope)`.
pub fn prelinearize<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Prelinearize::new().build(input, scope)
}

/// Builder for the `PrelinearizeTuple` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct PrelinearizeTuple {
    dtypes: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    layouts: ::std::option::Option<::std::vec::Vec<i64>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'PrelinearizeTuple' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct PrelinearizeTupleInst {
    /// An instance of a fully built PrelinearizeTuple Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl PrelinearizeTuple {
    /// Creates a new `PrelinearizeTuple`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `dtypes` attribute.
    pub fn dtypes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.dtypes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shapes` attribute.
    pub fn shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `layouts` attribute.
    pub fn layouts<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.layouts = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `PrelinearizeTuple` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        inputs: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(inputs.into(), scope)
    }
    fn build_impl(
        &self,
        inputs: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("PrelinearizeTuple", |nd| {
            nd.add_input(inputs);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.dtypes {
                nd.set_attr_type_list("dtypes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shapes {
                nd.set_attr_shape_list("shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.layouts {
                nd.set_attr_int_list("layouts", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'PrelinearizeTuple' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        inputs: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<PrelinearizeTupleInst> {
        let op = scope.new_operation("PrelinearizeTuple", |builder| {
            builder.add_input(inputs);
            if let ::std::option::Option::Some(value) = &self.dtypes {
                builder.set_attr_type_list("dtypes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shapes {
                builder.set_attr_shape_list("shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.layouts {
                builder.set_attr_int_list("layouts", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(PrelinearizeTupleInst { op })
    }
}
impl PrelinearizeTupleInst {
    /// Returns the 'output' Output of this 'PrelinearizeTuple' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'inputs' Input of this 'PrelinearizeTuple' operation.
    pub fn inputs(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<PrelinearizeTupleInst> for crate::Operation {
    fn from(inst: PrelinearizeTupleInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `PrelinearizeTuple::new().build(inputs, scope)`.
pub fn prelinearize_tuple<O0: ::std::convert::Into<crate::Output>>(
    inputs: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    PrelinearizeTuple::new().build(inputs, scope)
}

/// Builder for the `PreventGradient` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct PreventGradient {
    T: ::std::option::Option<crate::DataType>,
    message: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'PreventGradient' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct PreventGradientInst {
    /// An instance of a fully built PreventGradient Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl PreventGradient {
    /// Creates a new `PreventGradient`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `message` attribute.
    pub fn message<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.message = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `PreventGradient` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("PreventGradient", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.message {
                nd.set_attr_string("message", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'PreventGradient' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<PreventGradientInst> {
        let op = scope.new_operation("PreventGradient", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.message {
                builder.set_attr_string("message", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(PreventGradientInst { op })
    }
}
impl PreventGradientInst {
    /// Returns the 'output' Output of this 'PreventGradient' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'PreventGradient' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<PreventGradientInst> for crate::Operation {
    fn from(inst: PreventGradientInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `PreventGradient::new().build(input, scope)`.
pub fn prevent_gradient<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    PreventGradient::new().build(input, scope)
}

/// Builder for the `Print` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Print {
    T: ::std::option::Option<crate::DataType>,
    U: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    message: ::std::option::Option<::std::string::String>,
    first_n: ::std::option::Option<i64>,
    summarize: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Print' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct PrintInst {
    /// An instance of a fully built Print Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Print {
    /// Creates a new `Print`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `U` attribute.
    pub fn U<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.U = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `message` attribute.
    pub fn message<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.message = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `first_n` attribute.
    pub fn first_n<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.first_n = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `summarize` attribute.
    pub fn summarize<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.summarize = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Print` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        data: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), data.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        data: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Print", |nd| {
            nd.add_input(input);
            nd.add_input(data);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.U {
                nd.set_attr_type_list("U", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.message {
                nd.set_attr_string("message", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.first_n {
                nd.set_attr_int("first_n", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.summarize {
                nd.set_attr_int("summarize", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Print' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        data: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<PrintInst> {
        let op = scope.new_operation("Print", |builder| {
            builder.add_input(input);
            builder.add_input(data);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.U {
                builder.set_attr_type_list("U", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.message {
                builder.set_attr_string("message", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.first_n {
                builder.set_attr_int("first_n", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.summarize {
                builder.set_attr_int("summarize", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(PrintInst { op })
    }
}
impl PrintInst {
    /// Returns the 'output' Output of this 'Print' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'Print' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'data' Input of this 'Print' operation.
    pub fn data(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<PrintInst> for crate::Operation {
    fn from(inst: PrintInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Print::new().build(input, data, scope)`.
pub fn print<O0: ::std::convert::Into<crate::Output>, O1: ::std::convert::Into<crate::Output>>(
    input: O0,
    data: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Print::new().build(input, data, scope)
}

/// Builder for the `PrintV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct PrintV2 {
    output_stream: ::std::option::Option<::std::string::String>,
    end: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'PrintV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct PrintV2Inst {
    /// An instance of a fully built PrintV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl PrintV2 {
    /// Creates a new `PrintV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `output_stream` attribute.
    pub fn output_stream<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_stream = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `end` attribute.
    pub fn end<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.end = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `PrintV2` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("PrintV2", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.output_stream {
                nd.set_attr_string("output_stream", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.end {
                nd.set_attr_string("end", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'PrintV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<PrintV2Inst> {
        let op = scope.new_operation("PrintV2", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.output_stream {
                builder.set_attr_string("output_stream", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.end {
                builder.set_attr_string("end", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(PrintV2Inst { op })
    }
}
impl PrintV2Inst {
    /// Returns the 'input' Input of this 'PrintV2' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<PrintV2Inst> for crate::Operation {
    fn from(inst: PrintV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `PrintV2::new().build(input, scope)`.
pub fn print_v2<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    PrintV2::new().build(input, scope)
}

/// Builder for the `PriorityQueue` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct PriorityQueue {
    component_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    capacity: ::std::option::Option<i64>,
    container: ::std::option::Option<::std::string::String>,
    shared_name: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'PriorityQueue' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct PriorityQueueInst {
    /// An instance of a fully built PriorityQueue Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl PriorityQueue {
    /// Creates a new `PriorityQueue`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `component_types` attribute.
    pub fn component_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.component_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shapes` attribute.
    pub fn shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `capacity` attribute.
    pub fn capacity<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.capacity = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `container` attribute.
    pub fn container<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.container = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shared_name` attribute.
    pub fn shared_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.shared_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `PriorityQueue` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("PriorityQueue", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.component_types {
                nd.set_attr_type_list("component_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shapes {
                nd.set_attr_shape_list("shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.capacity {
                nd.set_attr_int("capacity", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.container {
                nd.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                nd.set_attr_string("shared_name", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'PriorityQueue' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(&self, scope: &mut crate::Scope) -> crate::Result<PriorityQueueInst> {
        let op = scope.new_operation("PriorityQueue", |builder| {
            if let ::std::option::Option::Some(value) = &self.component_types {
                builder.set_attr_type_list("component_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shapes {
                builder.set_attr_shape_list("shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.capacity {
                builder.set_attr_int("capacity", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.container {
                builder.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                builder.set_attr_string("shared_name", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(PriorityQueueInst { op })
    }
}
impl PriorityQueueInst {
    /// Returns the 'handle' Output of this 'PriorityQueue' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
}
impl From<PriorityQueueInst> for crate::Operation {
    fn from(inst: PriorityQueueInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `PriorityQueue::new().build(scope)`.
pub fn priority_queue(scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
    PriorityQueue::new().build(scope)
}

/// Builder for the `PriorityQueueV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct PriorityQueueV2 {
    component_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    capacity: ::std::option::Option<i64>,
    container: ::std::option::Option<::std::string::String>,
    shared_name: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'PriorityQueueV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct PriorityQueueV2Inst {
    /// An instance of a fully built PriorityQueueV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl PriorityQueueV2 {
    /// Creates a new `PriorityQueueV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `component_types` attribute.
    pub fn component_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.component_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shapes` attribute.
    pub fn shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `capacity` attribute.
    pub fn capacity<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.capacity = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `container` attribute.
    pub fn container<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.container = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shared_name` attribute.
    pub fn shared_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.shared_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `PriorityQueueV2` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("PriorityQueueV2", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.component_types {
                nd.set_attr_type_list("component_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shapes {
                nd.set_attr_shape_list("shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.capacity {
                nd.set_attr_int("capacity", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.container {
                nd.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                nd.set_attr_string("shared_name", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'PriorityQueueV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(&self, scope: &mut crate::Scope) -> crate::Result<PriorityQueueV2Inst> {
        let op = scope.new_operation("PriorityQueueV2", |builder| {
            if let ::std::option::Option::Some(value) = &self.component_types {
                builder.set_attr_type_list("component_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shapes {
                builder.set_attr_shape_list("shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.capacity {
                builder.set_attr_int("capacity", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.container {
                builder.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                builder.set_attr_string("shared_name", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(PriorityQueueV2Inst { op })
    }
}
impl PriorityQueueV2Inst {
    /// Returns the 'handle' Output of this 'PriorityQueueV2' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
}
impl From<PriorityQueueV2Inst> for crate::Operation {
    fn from(inst: PriorityQueueV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `PriorityQueueV2::new().build(scope)`.
pub fn priority_queue_v2(scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
    PriorityQueueV2::new().build(scope)
}

/// Builder for the `PrivateThreadPoolDataset` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct PrivateThreadPoolDataset {
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'PrivateThreadPoolDataset' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct PrivateThreadPoolDatasetInst {
    /// An instance of a fully built PrivateThreadPoolDataset Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl PrivateThreadPoolDataset {
    /// Creates a new `PrivateThreadPoolDataset`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `PrivateThreadPoolDataset` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input_dataset: O0,
        num_threads: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input_dataset.into(), num_threads.into(), scope)
    }
    fn build_impl(
        &self,
        input_dataset: crate::Output,
        num_threads: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("PrivateThreadPoolDataset", |nd| {
            nd.add_input(input_dataset);
            nd.add_input(num_threads);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'PrivateThreadPoolDataset' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_dataset: crate::Output,
        num_threads: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<PrivateThreadPoolDatasetInst> {
        let op = scope.new_operation("PrivateThreadPoolDataset", |builder| {
            builder.add_input(input_dataset);
            builder.add_input(num_threads);
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(PrivateThreadPoolDatasetInst { op })
    }
}
impl PrivateThreadPoolDatasetInst {
    /// Returns the 'handle' Output of this 'PrivateThreadPoolDataset' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_dataset' Input of this 'PrivateThreadPoolDataset' operation.
    pub fn input_dataset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'num_threads' Input of this 'PrivateThreadPoolDataset' operation.
    pub fn num_threads(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<PrivateThreadPoolDatasetInst> for crate::Operation {
    fn from(inst: PrivateThreadPoolDatasetInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `PrivateThreadPoolDataset::new().build(input_dataset, num_threads, scope)`.
pub fn private_thread_pool_dataset<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    input_dataset: O0,
    num_threads: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    PrivateThreadPoolDataset::new().build(input_dataset, num_threads, scope)
}

/// Builder for the `Prod` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Prod {
    keep_dims: ::std::option::Option<bool>,
    T: ::std::option::Option<crate::DataType>,
    Tidx: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Prod' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ProdInst {
    /// An instance of a fully built Prod Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Prod {
    /// Creates a new `Prod`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `keep_dims` attribute.
    pub fn keep_dims<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.keep_dims = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tidx` attribute.
    pub fn Tidx<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Tidx = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Prod` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        reduction_indices: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), reduction_indices.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        reduction_indices: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Prod", |nd| {
            nd.add_input(input);
            nd.add_input(reduction_indices);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.keep_dims {
                nd.set_attr_bool("keep_dims", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tidx {
                nd.set_attr_type("Tidx", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Prod' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        reduction_indices: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ProdInst> {
        let op = scope.new_operation("Prod", |builder| {
            builder.add_input(input);
            builder.add_input(reduction_indices);
            if let ::std::option::Option::Some(value) = &self.keep_dims {
                builder.set_attr_bool("keep_dims", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tidx {
                builder.set_attr_type("Tidx", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ProdInst { op })
    }
}
impl ProdInst {
    /// Returns the 'output' Output of this 'Prod' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'Prod' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'reduction_indices' Input of this 'Prod' operation.
    pub fn reduction_indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<ProdInst> for crate::Operation {
    fn from(inst: ProdInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Prod::new().build(input, reduction_indices, scope)`.
pub fn prod<O0: ::std::convert::Into<crate::Output>, O1: ::std::convert::Into<crate::Output>>(
    input: O0,
    reduction_indices: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Prod::new().build(input, reduction_indices, scope)
}

/// Builder for the `PyFunc` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct PyFunc {
    token: ::std::option::Option<::std::string::String>,
    Tin: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    Tout: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'PyFunc' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct PyFuncInst {
    /// An instance of a fully built PyFunc Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl PyFunc {
    /// Creates a new `PyFunc`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `token` attribute.
    pub fn token<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.token = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tin` attribute.
    pub fn Tin<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tin = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tout` attribute.
    pub fn Tout<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tout = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `PyFunc` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("PyFunc", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.token {
                nd.set_attr_string("token", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tin {
                nd.set_attr_type_list("Tin", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tout {
                nd.set_attr_type_list("Tout", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'PyFunc' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<PyFuncInst> {
        let op = scope.new_operation("PyFunc", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.token {
                builder.set_attr_string("token", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tin {
                builder.set_attr_type_list("Tin", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tout {
                builder.set_attr_type_list("Tout", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(PyFuncInst { op })
    }
}
impl PyFuncInst {
    /// Returns the 'output' Output of this 'PyFunc' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'PyFunc' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<PyFuncInst> for crate::Operation {
    fn from(inst: PyFuncInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `PyFunc::new().build(input, scope)`.
pub fn py_func<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    PyFunc::new().build(input, scope)
}

/// Builder for the `PyFuncStateless` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct PyFuncStateless {
    token: ::std::option::Option<::std::string::String>,
    Tin: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    Tout: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'PyFuncStateless' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct PyFuncStatelessInst {
    /// An instance of a fully built PyFuncStateless Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl PyFuncStateless {
    /// Creates a new `PyFuncStateless`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `token` attribute.
    pub fn token<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.token = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tin` attribute.
    pub fn Tin<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tin = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tout` attribute.
    pub fn Tout<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tout = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `PyFuncStateless` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("PyFuncStateless", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.token {
                nd.set_attr_string("token", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tin {
                nd.set_attr_type_list("Tin", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tout {
                nd.set_attr_type_list("Tout", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'PyFuncStateless' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<PyFuncStatelessInst> {
        let op = scope.new_operation("PyFuncStateless", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.token {
                builder.set_attr_string("token", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tin {
                builder.set_attr_type_list("Tin", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tout {
                builder.set_attr_type_list("Tout", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(PyFuncStatelessInst { op })
    }
}
impl PyFuncStatelessInst {
    /// Returns the 'output' Output of this 'PyFuncStateless' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'PyFuncStateless' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<PyFuncStatelessInst> for crate::Operation {
    fn from(inst: PyFuncStatelessInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `PyFuncStateless::new().build(input, scope)`.
pub fn py_func_stateless<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    PyFuncStateless::new().build(input, scope)
}

/// Builder for the `Qr` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Qr {
    full_matrices: ::std::option::Option<bool>,
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Qr' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct QrInst {
    /// An instance of a fully built Qr Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Qr {
    /// Creates a new `Qr`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `full_matrices` attribute.
    pub fn full_matrices<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.full_matrices = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Qr` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Qr", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.full_matrices {
                nd.set_attr_bool("full_matrices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Qr' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<QrInst> {
        let op = scope.new_operation("Qr", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.full_matrices {
                builder.set_attr_bool("full_matrices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(QrInst { op })
    }
}
impl QrInst {
    /// Returns the 'q' Output of this 'Qr' operation.
    pub fn q(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'r' Output of this 'Qr' operation.
    pub fn r(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'input' Input of this 'Qr' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<QrInst> for crate::Operation {
    fn from(inst: QrInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Qr::new().build(input, scope)`.
pub fn qr<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Qr::new().build(input, scope)
}

/// Builder for the `QuantizeAndDequantize` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct QuantizeAndDequantize {
    signed_input: ::std::option::Option<bool>,
    num_bits: ::std::option::Option<i64>,
    range_given: ::std::option::Option<bool>,
    input_min: ::std::option::Option<f32>,
    input_max: ::std::option::Option<f32>,
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'QuantizeAndDequantize' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct QuantizeAndDequantizeInst {
    /// An instance of a fully built QuantizeAndDequantize Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl QuantizeAndDequantize {
    /// Creates a new `QuantizeAndDequantize`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `signed_input` attribute.
    pub fn signed_input<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.signed_input = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `num_bits` attribute.
    pub fn num_bits<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.num_bits = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `range_given` attribute.
    pub fn range_given<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.range_given = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `input_min` attribute.
    pub fn input_min<ArgType: ::std::convert::Into<f32>>(mut self, value: ArgType) -> Self {
        self.input_min = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `input_max` attribute.
    pub fn input_max<ArgType: ::std::convert::Into<f32>>(mut self, value: ArgType) -> Self {
        self.input_max = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `QuantizeAndDequantize` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("QuantizeAndDequantize", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.signed_input {
                nd.set_attr_bool("signed_input", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_bits {
                nd.set_attr_int("num_bits", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.range_given {
                nd.set_attr_bool("range_given", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.input_min {
                nd.set_attr_float("input_min", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.input_max {
                nd.set_attr_float("input_max", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'QuantizeAndDequantize' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<QuantizeAndDequantizeInst> {
        let op = scope.new_operation("QuantizeAndDequantize", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.signed_input {
                builder.set_attr_bool("signed_input", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_bits {
                builder.set_attr_int("num_bits", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.range_given {
                builder.set_attr_bool("range_given", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.input_min {
                builder.set_attr_float("input_min", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.input_max {
                builder.set_attr_float("input_max", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(QuantizeAndDequantizeInst { op })
    }
}
impl QuantizeAndDequantizeInst {
    /// Returns the 'output' Output of this 'QuantizeAndDequantize' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'QuantizeAndDequantize' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<QuantizeAndDequantizeInst> for crate::Operation {
    fn from(inst: QuantizeAndDequantizeInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `QuantizeAndDequantize::new().build(input, scope)`.
pub fn quantize_and_dequantize<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    QuantizeAndDequantize::new().build(input, scope)
}

/// Builder for the `QuantizeAndDequantizeV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct QuantizeAndDequantizeV2 {
    signed_input: ::std::option::Option<bool>,
    num_bits: ::std::option::Option<i64>,
    range_given: ::std::option::Option<bool>,
    T: ::std::option::Option<crate::DataType>,
    round_mode: ::std::option::Option<::std::string::String>,
    narrow_range: ::std::option::Option<bool>,
    axis: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'QuantizeAndDequantizeV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct QuantizeAndDequantizeV2Inst {
    /// An instance of a fully built QuantizeAndDequantizeV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl QuantizeAndDequantizeV2 {
    /// Creates a new `QuantizeAndDequantizeV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `signed_input` attribute.
    pub fn signed_input<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.signed_input = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `num_bits` attribute.
    pub fn num_bits<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.num_bits = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `range_given` attribute.
    pub fn range_given<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.range_given = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `round_mode` attribute.
    pub fn round_mode<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.round_mode = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `narrow_range` attribute.
    pub fn narrow_range<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.narrow_range = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `axis` attribute.
    pub fn axis<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.axis = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `QuantizeAndDequantizeV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        input_min: O1,
        input_max: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), input_min.into(), input_max.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        input_min: crate::Output,
        input_max: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("QuantizeAndDequantizeV2", |nd| {
            nd.add_input(input);
            nd.add_input(input_min);
            nd.add_input(input_max);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.signed_input {
                nd.set_attr_bool("signed_input", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_bits {
                nd.set_attr_int("num_bits", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.range_given {
                nd.set_attr_bool("range_given", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.round_mode {
                nd.set_attr_string("round_mode", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.narrow_range {
                nd.set_attr_bool("narrow_range", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.axis {
                nd.set_attr_int("axis", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'QuantizeAndDequantizeV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        input_min: crate::Output,
        input_max: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<QuantizeAndDequantizeV2Inst> {
        let op = scope.new_operation("QuantizeAndDequantizeV2", |builder| {
            builder.add_input(input);
            builder.add_input(input_min);
            builder.add_input(input_max);
            if let ::std::option::Option::Some(value) = &self.signed_input {
                builder.set_attr_bool("signed_input", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_bits {
                builder.set_attr_int("num_bits", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.range_given {
                builder.set_attr_bool("range_given", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.round_mode {
                builder.set_attr_string("round_mode", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.narrow_range {
                builder.set_attr_bool("narrow_range", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.axis {
                builder.set_attr_int("axis", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(QuantizeAndDequantizeV2Inst { op })
    }
}
impl QuantizeAndDequantizeV2Inst {
    /// Returns the 'output' Output of this 'QuantizeAndDequantizeV2' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'QuantizeAndDequantizeV2' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'input_min' Input of this 'QuantizeAndDequantizeV2' operation.
    pub fn input_min(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'input_max' Input of this 'QuantizeAndDequantizeV2' operation.
    pub fn input_max(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<QuantizeAndDequantizeV2Inst> for crate::Operation {
    fn from(inst: QuantizeAndDequantizeV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `QuantizeAndDequantizeV2::new().build(input, input_min, input_max, scope)`.
pub fn quantize_and_dequantize_v2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    input: O0,
    input_min: O1,
    input_max: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    QuantizeAndDequantizeV2::new().build(input, input_min, input_max, scope)
}

/// Builder for the `QuantizeAndDequantizeV3` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct QuantizeAndDequantizeV3 {
    signed_input: ::std::option::Option<bool>,
    range_given: ::std::option::Option<bool>,
    T: ::std::option::Option<crate::DataType>,
    narrow_range: ::std::option::Option<bool>,
    axis: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'QuantizeAndDequantizeV3' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct QuantizeAndDequantizeV3Inst {
    /// An instance of a fully built QuantizeAndDequantizeV3 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl QuantizeAndDequantizeV3 {
    /// Creates a new `QuantizeAndDequantizeV3`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `signed_input` attribute.
    pub fn signed_input<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.signed_input = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `range_given` attribute.
    pub fn range_given<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.range_given = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `narrow_range` attribute.
    pub fn narrow_range<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.narrow_range = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `axis` attribute.
    pub fn axis<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.axis = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `QuantizeAndDequantizeV3` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        input_min: O1,
        input_max: O2,
        num_bits: O3,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            input.into(),
            input_min.into(),
            input_max.into(),
            num_bits.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        input: crate::Output,
        input_min: crate::Output,
        input_max: crate::Output,
        num_bits: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("QuantizeAndDequantizeV3", |nd| {
            nd.add_input(input);
            nd.add_input(input_min);
            nd.add_input(input_max);
            nd.add_input(num_bits);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.signed_input {
                nd.set_attr_bool("signed_input", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.range_given {
                nd.set_attr_bool("range_given", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.narrow_range {
                nd.set_attr_bool("narrow_range", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.axis {
                nd.set_attr_int("axis", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'QuantizeAndDequantizeV3' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        input_min: crate::Output,
        input_max: crate::Output,
        num_bits: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<QuantizeAndDequantizeV3Inst> {
        let op = scope.new_operation("QuantizeAndDequantizeV3", |builder| {
            builder.add_input(input);
            builder.add_input(input_min);
            builder.add_input(input_max);
            builder.add_input(num_bits);
            if let ::std::option::Option::Some(value) = &self.signed_input {
                builder.set_attr_bool("signed_input", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.range_given {
                builder.set_attr_bool("range_given", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.narrow_range {
                builder.set_attr_bool("narrow_range", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.axis {
                builder.set_attr_int("axis", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(QuantizeAndDequantizeV3Inst { op })
    }
}
impl QuantizeAndDequantizeV3Inst {
    /// Returns the 'output' Output of this 'QuantizeAndDequantizeV3' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'QuantizeAndDequantizeV3' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'input_min' Input of this 'QuantizeAndDequantizeV3' operation.
    pub fn input_min(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'input_max' Input of this 'QuantizeAndDequantizeV3' operation.
    pub fn input_max(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'num_bits' Input of this 'QuantizeAndDequantizeV3' operation.
    pub fn num_bits(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
}
impl From<QuantizeAndDequantizeV3Inst> for crate::Operation {
    fn from(inst: QuantizeAndDequantizeV3Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `QuantizeAndDequantizeV3::new().build(input, input_min, input_max, num_bits, scope)`.
pub fn quantize_and_dequantize_v3<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
>(
    input: O0,
    input_min: O1,
    input_max: O2,
    num_bits: O3,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    QuantizeAndDequantizeV3::new().build(input, input_min, input_max, num_bits, scope)
}

/// Builder for the `QuantizeAndDequantizeV4` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct QuantizeAndDequantizeV4 {
    signed_input: ::std::option::Option<bool>,
    num_bits: ::std::option::Option<i64>,
    range_given: ::std::option::Option<bool>,
    T: ::std::option::Option<crate::DataType>,
    round_mode: ::std::option::Option<::std::string::String>,
    narrow_range: ::std::option::Option<bool>,
    axis: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'QuantizeAndDequantizeV4' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct QuantizeAndDequantizeV4Inst {
    /// An instance of a fully built QuantizeAndDequantizeV4 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl QuantizeAndDequantizeV4 {
    /// Creates a new `QuantizeAndDequantizeV4`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `signed_input` attribute.
    pub fn signed_input<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.signed_input = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `num_bits` attribute.
    pub fn num_bits<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.num_bits = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `range_given` attribute.
    pub fn range_given<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.range_given = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `round_mode` attribute.
    pub fn round_mode<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.round_mode = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `narrow_range` attribute.
    pub fn narrow_range<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.narrow_range = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `axis` attribute.
    pub fn axis<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.axis = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `QuantizeAndDequantizeV4` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        input_min: O1,
        input_max: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), input_min.into(), input_max.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        input_min: crate::Output,
        input_max: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("QuantizeAndDequantizeV4", |nd| {
            nd.add_input(input);
            nd.add_input(input_min);
            nd.add_input(input_max);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.signed_input {
                nd.set_attr_bool("signed_input", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_bits {
                nd.set_attr_int("num_bits", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.range_given {
                nd.set_attr_bool("range_given", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.round_mode {
                nd.set_attr_string("round_mode", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.narrow_range {
                nd.set_attr_bool("narrow_range", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.axis {
                nd.set_attr_int("axis", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'QuantizeAndDequantizeV4' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        input_min: crate::Output,
        input_max: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<QuantizeAndDequantizeV4Inst> {
        let op = scope.new_operation("QuantizeAndDequantizeV4", |builder| {
            builder.add_input(input);
            builder.add_input(input_min);
            builder.add_input(input_max);
            if let ::std::option::Option::Some(value) = &self.signed_input {
                builder.set_attr_bool("signed_input", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_bits {
                builder.set_attr_int("num_bits", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.range_given {
                builder.set_attr_bool("range_given", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.round_mode {
                builder.set_attr_string("round_mode", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.narrow_range {
                builder.set_attr_bool("narrow_range", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.axis {
                builder.set_attr_int("axis", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(QuantizeAndDequantizeV4Inst { op })
    }
}
impl QuantizeAndDequantizeV4Inst {
    /// Returns the 'output' Output of this 'QuantizeAndDequantizeV4' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'QuantizeAndDequantizeV4' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'input_min' Input of this 'QuantizeAndDequantizeV4' operation.
    pub fn input_min(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'input_max' Input of this 'QuantizeAndDequantizeV4' operation.
    pub fn input_max(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<QuantizeAndDequantizeV4Inst> for crate::Operation {
    fn from(inst: QuantizeAndDequantizeV4Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `QuantizeAndDequantizeV4::new().build(input, input_min, input_max, scope)`.
pub fn quantize_and_dequantize_v4<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    input: O0,
    input_min: O1,
    input_max: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    QuantizeAndDequantizeV4::new().build(input, input_min, input_max, scope)
}

/// Builder for the `QuantizeAndDequantizeV4Grad` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct QuantizeAndDequantizeV4Grad {
    T: ::std::option::Option<crate::DataType>,
    axis: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'QuantizeAndDequantizeV4Grad' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct QuantizeAndDequantizeV4GradInst {
    /// An instance of a fully built QuantizeAndDequantizeV4Grad Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl QuantizeAndDequantizeV4Grad {
    /// Creates a new `QuantizeAndDequantizeV4Grad`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `axis` attribute.
    pub fn axis<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.axis = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `QuantizeAndDequantizeV4Grad` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
    >(
        &self,
        gradients: O0,
        input: O1,
        input_min: O2,
        input_max: O3,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            gradients.into(),
            input.into(),
            input_min.into(),
            input_max.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        gradients: crate::Output,
        input: crate::Output,
        input_min: crate::Output,
        input_max: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("QuantizeAndDequantizeV4Grad", |nd| {
            nd.add_input(gradients);
            nd.add_input(input);
            nd.add_input(input_min);
            nd.add_input(input_max);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.axis {
                nd.set_attr_int("axis", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'QuantizeAndDequantizeV4Grad' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        gradients: crate::Output,
        input: crate::Output,
        input_min: crate::Output,
        input_max: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<QuantizeAndDequantizeV4GradInst> {
        let op = scope.new_operation("QuantizeAndDequantizeV4Grad", |builder| {
            builder.add_input(gradients);
            builder.add_input(input);
            builder.add_input(input_min);
            builder.add_input(input_max);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.axis {
                builder.set_attr_int("axis", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(QuantizeAndDequantizeV4GradInst { op })
    }
}
impl QuantizeAndDequantizeV4GradInst {
    /// Returns the 'input_backprop' Output of this 'QuantizeAndDequantizeV4Grad' operation.
    pub fn input_backprop(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_min_backprop' Output of this 'QuantizeAndDequantizeV4Grad' operation.
    pub fn input_min_backprop(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'input_max_backprop' Output of this 'QuantizeAndDequantizeV4Grad' operation.
    pub fn input_max_backprop(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns the 'gradients' Input of this 'QuantizeAndDequantizeV4Grad' operation.
    pub fn gradients(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'QuantizeAndDequantizeV4Grad' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'input_min' Input of this 'QuantizeAndDequantizeV4Grad' operation.
    pub fn input_min(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'input_max' Input of this 'QuantizeAndDequantizeV4Grad' operation.
    pub fn input_max(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
}
impl From<QuantizeAndDequantizeV4GradInst> for crate::Operation {
    fn from(inst: QuantizeAndDequantizeV4GradInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `QuantizeAndDequantizeV4Grad::new().build(gradients, input, input_min, input_max, scope)`.
pub fn quantize_and_dequantize_v4_grad<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
>(
    gradients: O0,
    input: O1,
    input_min: O2,
    input_max: O3,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    QuantizeAndDequantizeV4Grad::new().build(gradients, input, input_min, input_max, scope)
}

/// Builder for the `QuantizeDownAndShrinkRange` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct QuantizeDownAndShrinkRange {
    Tinput: ::std::option::Option<crate::DataType>,
    out_type: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'QuantizeDownAndShrinkRange' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct QuantizeDownAndShrinkRangeInst {
    /// An instance of a fully built QuantizeDownAndShrinkRange Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl QuantizeDownAndShrinkRange {
    /// Creates a new `QuantizeDownAndShrinkRange`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `Tinput` attribute.
    pub fn Tinput<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tinput = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `out_type` attribute.
    pub fn out_type<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.out_type = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `QuantizeDownAndShrinkRange` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        input_min: O1,
        input_max: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), input_min.into(), input_max.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        input_min: crate::Output,
        input_max: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("QuantizeDownAndShrinkRange", |nd| {
            nd.add_input(input);
            nd.add_input(input_min);
            nd.add_input(input_max);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.Tinput {
                nd.set_attr_type("Tinput", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.out_type {
                nd.set_attr_type("out_type", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'QuantizeDownAndShrinkRange' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        input_min: crate::Output,
        input_max: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<QuantizeDownAndShrinkRangeInst> {
        let op = scope.new_operation("QuantizeDownAndShrinkRange", |builder| {
            builder.add_input(input);
            builder.add_input(input_min);
            builder.add_input(input_max);
            if let ::std::option::Option::Some(value) = &self.Tinput {
                builder.set_attr_type("Tinput", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.out_type {
                builder.set_attr_type("out_type", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(QuantizeDownAndShrinkRangeInst { op })
    }
}
impl QuantizeDownAndShrinkRangeInst {
    /// Returns the 'output' Output of this 'QuantizeDownAndShrinkRange' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'output_min' Output of this 'QuantizeDownAndShrinkRange' operation.
    pub fn output_min(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'output_max' Output of this 'QuantizeDownAndShrinkRange' operation.
    pub fn output_max(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns the 'input' Input of this 'QuantizeDownAndShrinkRange' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'input_min' Input of this 'QuantizeDownAndShrinkRange' operation.
    pub fn input_min(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'input_max' Input of this 'QuantizeDownAndShrinkRange' operation.
    pub fn input_max(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<QuantizeDownAndShrinkRangeInst> for crate::Operation {
    fn from(inst: QuantizeDownAndShrinkRangeInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `QuantizeDownAndShrinkRange::new().build(input, input_min, input_max, scope)`.
pub fn quantize_down_and_shrink_range<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    input: O0,
    input_min: O1,
    input_max: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    QuantizeDownAndShrinkRange::new().build(input, input_min, input_max, scope)
}

/// Builder for the `QuantizeV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct QuantizeV2 {
    T: ::std::option::Option<crate::DataType>,
    mode: ::std::option::Option<::std::string::String>,
    round_mode: ::std::option::Option<::std::string::String>,
    narrow_range: ::std::option::Option<bool>,
    axis: ::std::option::Option<i64>,
    ensure_minimum_range: ::std::option::Option<f32>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'QuantizeV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct QuantizeV2Inst {
    /// An instance of a fully built QuantizeV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl QuantizeV2 {
    /// Creates a new `QuantizeV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `mode` attribute.
    pub fn mode<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.mode = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `round_mode` attribute.
    pub fn round_mode<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.round_mode = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `narrow_range` attribute.
    pub fn narrow_range<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.narrow_range = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `axis` attribute.
    pub fn axis<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.axis = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `ensure_minimum_range` attribute.
    pub fn ensure_minimum_range<ArgType: ::std::convert::Into<f32>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.ensure_minimum_range = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `QuantizeV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        min_range: O1,
        max_range: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), min_range.into(), max_range.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        min_range: crate::Output,
        max_range: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("QuantizeV2", |nd| {
            nd.add_input(input);
            nd.add_input(min_range);
            nd.add_input(max_range);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.mode {
                nd.set_attr_string("mode", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.round_mode {
                nd.set_attr_string("round_mode", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.narrow_range {
                nd.set_attr_bool("narrow_range", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.axis {
                nd.set_attr_int("axis", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.ensure_minimum_range {
                nd.set_attr_float("ensure_minimum_range", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'QuantizeV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        min_range: crate::Output,
        max_range: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<QuantizeV2Inst> {
        let op = scope.new_operation("QuantizeV2", |builder| {
            builder.add_input(input);
            builder.add_input(min_range);
            builder.add_input(max_range);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.mode {
                builder.set_attr_string("mode", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.round_mode {
                builder.set_attr_string("round_mode", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.narrow_range {
                builder.set_attr_bool("narrow_range", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.axis {
                builder.set_attr_int("axis", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.ensure_minimum_range {
                builder.set_attr_float("ensure_minimum_range", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(QuantizeV2Inst { op })
    }
}
impl QuantizeV2Inst {
    /// Returns the 'output' Output of this 'QuantizeV2' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'output_min' Output of this 'QuantizeV2' operation.
    pub fn output_min(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'output_max' Output of this 'QuantizeV2' operation.
    pub fn output_max(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns the 'input' Input of this 'QuantizeV2' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'min_range' Input of this 'QuantizeV2' operation.
    pub fn min_range(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'max_range' Input of this 'QuantizeV2' operation.
    pub fn max_range(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<QuantizeV2Inst> for crate::Operation {
    fn from(inst: QuantizeV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `QuantizeV2::new().build(input, min_range, max_range, scope)`.
pub fn quantize_v2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    input: O0,
    min_range: O1,
    max_range: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    QuantizeV2::new().build(input, min_range, max_range, scope)
}

/// Builder for the `QuantizedAdd` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct QuantizedAdd {
    T1: ::std::option::Option<crate::DataType>,
    T2: ::std::option::Option<crate::DataType>,
    Toutput: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'QuantizedAdd' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct QuantizedAddInst {
    /// An instance of a fully built QuantizedAdd Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl QuantizedAdd {
    /// Creates a new `QuantizedAdd`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T1` attribute.
    pub fn T1<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T1 = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T2` attribute.
    pub fn T2<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T2 = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Toutput` attribute.
    pub fn Toutput<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Toutput = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `QuantizedAdd` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
    >(
        &self,
        x: O0,
        y: O1,
        min_x: O2,
        max_x: O3,
        min_y: O4,
        max_y: O5,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            x.into(),
            y.into(),
            min_x.into(),
            max_x.into(),
            min_y.into(),
            max_y.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        x: crate::Output,
        y: crate::Output,
        min_x: crate::Output,
        max_x: crate::Output,
        min_y: crate::Output,
        max_y: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("QuantizedAdd", |nd| {
            nd.add_input(x);
            nd.add_input(y);
            nd.add_input(min_x);
            nd.add_input(max_x);
            nd.add_input(min_y);
            nd.add_input(max_y);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T1 {
                nd.set_attr_type("T1", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T2 {
                nd.set_attr_type("T2", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Toutput {
                nd.set_attr_type("Toutput", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'QuantizedAdd' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        y: crate::Output,
        min_x: crate::Output,
        max_x: crate::Output,
        min_y: crate::Output,
        max_y: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<QuantizedAddInst> {
        let op = scope.new_operation("QuantizedAdd", |builder| {
            builder.add_input(x);
            builder.add_input(y);
            builder.add_input(min_x);
            builder.add_input(max_x);
            builder.add_input(min_y);
            builder.add_input(max_y);
            if let ::std::option::Option::Some(value) = &self.T1 {
                builder.set_attr_type("T1", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T2 {
                builder.set_attr_type("T2", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Toutput {
                builder.set_attr_type("Toutput", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(QuantizedAddInst { op })
    }
}
impl QuantizedAddInst {
    /// Returns the 'z' Output of this 'QuantizedAdd' operation.
    pub fn z(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'min_z' Output of this 'QuantizedAdd' operation.
    pub fn min_z(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'max_z' Output of this 'QuantizedAdd' operation.
    pub fn max_z(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns the 'x' Input of this 'QuantizedAdd' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'y' Input of this 'QuantizedAdd' operation.
    pub fn y(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'min_x' Input of this 'QuantizedAdd' operation.
    pub fn min_x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'max_x' Input of this 'QuantizedAdd' operation.
    pub fn max_x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'min_y' Input of this 'QuantizedAdd' operation.
    pub fn min_y(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
    /// Returns the 'max_y' Input of this 'QuantizedAdd' operation.
    pub fn max_y(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 5,
        }
    }
}
impl From<QuantizedAddInst> for crate::Operation {
    fn from(inst: QuantizedAddInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `QuantizedAdd::new().build(x, y, min_x, max_x, min_y, max_y, scope)`.
pub fn quantized_add<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
>(
    x: O0,
    y: O1,
    min_x: O2,
    max_x: O3,
    min_y: O4,
    max_y: O5,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    QuantizedAdd::new().build(x, y, min_x, max_x, min_y, max_y, scope)
}

/// Builder for the `QuantizedAvgPool` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct QuantizedAvgPool {
    T: ::std::option::Option<crate::DataType>,
    ksize: ::std::option::Option<::std::vec::Vec<i64>>,
    strides: ::std::option::Option<::std::vec::Vec<i64>>,
    padding: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'QuantizedAvgPool' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct QuantizedAvgPoolInst {
    /// An instance of a fully built QuantizedAvgPool Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl QuantizedAvgPool {
    /// Creates a new `QuantizedAvgPool`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `ksize` attribute.
    pub fn ksize<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.ksize = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `strides` attribute.
    pub fn strides<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.strides = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `padding` attribute.
    pub fn padding<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.padding = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `QuantizedAvgPool` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        min_input: O1,
        max_input: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), min_input.into(), max_input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        min_input: crate::Output,
        max_input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("QuantizedAvgPool", |nd| {
            nd.add_input(input);
            nd.add_input(min_input);
            nd.add_input(max_input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.ksize {
                nd.set_attr_int_list("ksize", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.strides {
                nd.set_attr_int_list("strides", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding {
                nd.set_attr_string("padding", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'QuantizedAvgPool' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        min_input: crate::Output,
        max_input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<QuantizedAvgPoolInst> {
        let op = scope.new_operation("QuantizedAvgPool", |builder| {
            builder.add_input(input);
            builder.add_input(min_input);
            builder.add_input(max_input);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.ksize {
                builder.set_attr_int_list("ksize", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.strides {
                builder.set_attr_int_list("strides", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding {
                builder.set_attr_string("padding", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(QuantizedAvgPoolInst { op })
    }
}
impl QuantizedAvgPoolInst {
    /// Returns the 'output' Output of this 'QuantizedAvgPool' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'min_output' Output of this 'QuantizedAvgPool' operation.
    pub fn min_output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'max_output' Output of this 'QuantizedAvgPool' operation.
    pub fn max_output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns the 'input' Input of this 'QuantizedAvgPool' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'min_input' Input of this 'QuantizedAvgPool' operation.
    pub fn min_input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'max_input' Input of this 'QuantizedAvgPool' operation.
    pub fn max_input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<QuantizedAvgPoolInst> for crate::Operation {
    fn from(inst: QuantizedAvgPoolInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `QuantizedAvgPool::new().build(input, min_input, max_input, scope)`.
pub fn quantized_avg_pool<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    input: O0,
    min_input: O1,
    max_input: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    QuantizedAvgPool::new().build(input, min_input, max_input, scope)
}

/// Builder for the `QuantizedBatchNormWithGlobalNormalization` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct QuantizedBatchNormWithGlobalNormalization {
    Tinput: ::std::option::Option<crate::DataType>,
    out_type: ::std::option::Option<crate::DataType>,
    variance_epsilon: ::std::option::Option<f32>,
    scale_after_normalization: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'QuantizedBatchNormWithGlobalNormalization' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct QuantizedBatchNormWithGlobalNormalizationInst {
    /// An instance of a fully built QuantizedBatchNormWithGlobalNormalization Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl QuantizedBatchNormWithGlobalNormalization {
    /// Creates a new `QuantizedBatchNormWithGlobalNormalization`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `Tinput` attribute.
    pub fn Tinput<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tinput = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `out_type` attribute.
    pub fn out_type<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.out_type = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `variance_epsilon` attribute.
    pub fn variance_epsilon<ArgType: ::std::convert::Into<f32>>(mut self, value: ArgType) -> Self {
        self.variance_epsilon = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `scale_after_normalization` attribute.
    pub fn scale_after_normalization<ArgType: ::std::convert::Into<bool>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.scale_after_normalization = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `QuantizedBatchNormWithGlobalNormalization` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
        O6: ::std::convert::Into<crate::Output>,
        O7: ::std::convert::Into<crate::Output>,
        O8: ::std::convert::Into<crate::Output>,
        O9: ::std::convert::Into<crate::Output>,
        O10: ::std::convert::Into<crate::Output>,
        O11: ::std::convert::Into<crate::Output>,
        O12: ::std::convert::Into<crate::Output>,
        O13: ::std::convert::Into<crate::Output>,
        O14: ::std::convert::Into<crate::Output>,
    >(
        &self,
        t: O0,
        t_min: O1,
        t_max: O2,
        m: O3,
        m_min: O4,
        m_max: O5,
        v: O6,
        v_min: O7,
        v_max: O8,
        beta: O9,
        beta_min: O10,
        beta_max: O11,
        gamma: O12,
        gamma_min: O13,
        gamma_max: O14,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            t.into(),
            t_min.into(),
            t_max.into(),
            m.into(),
            m_min.into(),
            m_max.into(),
            v.into(),
            v_min.into(),
            v_max.into(),
            beta.into(),
            beta_min.into(),
            beta_max.into(),
            gamma.into(),
            gamma_min.into(),
            gamma_max.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        t: crate::Output,
        t_min: crate::Output,
        t_max: crate::Output,
        m: crate::Output,
        m_min: crate::Output,
        m_max: crate::Output,
        v: crate::Output,
        v_min: crate::Output,
        v_max: crate::Output,
        beta: crate::Output,
        beta_min: crate::Output,
        beta_max: crate::Output,
        gamma: crate::Output,
        gamma_min: crate::Output,
        gamma_max: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("QuantizedBatchNormWithGlobalNormalization", |nd| {
            nd.add_input(t);
            nd.add_input(t_min);
            nd.add_input(t_max);
            nd.add_input(m);
            nd.add_input(m_min);
            nd.add_input(m_max);
            nd.add_input(v);
            nd.add_input(v_min);
            nd.add_input(v_max);
            nd.add_input(beta);
            nd.add_input(beta_min);
            nd.add_input(beta_max);
            nd.add_input(gamma);
            nd.add_input(gamma_min);
            nd.add_input(gamma_max);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.Tinput {
                nd.set_attr_type("Tinput", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.out_type {
                nd.set_attr_type("out_type", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.variance_epsilon {
                nd.set_attr_float("variance_epsilon", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.scale_after_normalization {
                nd.set_attr_bool("scale_after_normalization", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'QuantizedBatchNormWithGlobalNormalization' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        t: crate::Output,
        t_min: crate::Output,
        t_max: crate::Output,
        m: crate::Output,
        m_min: crate::Output,
        m_max: crate::Output,
        v: crate::Output,
        v_min: crate::Output,
        v_max: crate::Output,
        beta: crate::Output,
        beta_min: crate::Output,
        beta_max: crate::Output,
        gamma: crate::Output,
        gamma_min: crate::Output,
        gamma_max: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<QuantizedBatchNormWithGlobalNormalizationInst> {
        let op = scope.new_operation("QuantizedBatchNormWithGlobalNormalization", |builder| {
            builder.add_input(t);
            builder.add_input(t_min);
            builder.add_input(t_max);
            builder.add_input(m);
            builder.add_input(m_min);
            builder.add_input(m_max);
            builder.add_input(v);
            builder.add_input(v_min);
            builder.add_input(v_max);
            builder.add_input(beta);
            builder.add_input(beta_min);
            builder.add_input(beta_max);
            builder.add_input(gamma);
            builder.add_input(gamma_min);
            builder.add_input(gamma_max);
            if let ::std::option::Option::Some(value) = &self.Tinput {
                builder.set_attr_type("Tinput", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.out_type {
                builder.set_attr_type("out_type", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.variance_epsilon {
                builder.set_attr_float("variance_epsilon", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.scale_after_normalization {
                builder.set_attr_bool("scale_after_normalization", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(QuantizedBatchNormWithGlobalNormalizationInst { op })
    }
}
impl QuantizedBatchNormWithGlobalNormalizationInst {
    /// Returns the 'result' Output of this 'QuantizedBatchNormWithGlobalNormalization' operation.
    pub fn result(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'result_min' Output of this 'QuantizedBatchNormWithGlobalNormalization' operation.
    pub fn result_min(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'result_max' Output of this 'QuantizedBatchNormWithGlobalNormalization' operation.
    pub fn result_max(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns the 't' Input of this 'QuantizedBatchNormWithGlobalNormalization' operation.
    pub fn t(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 't_min' Input of this 'QuantizedBatchNormWithGlobalNormalization' operation.
    pub fn t_min(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 't_max' Input of this 'QuantizedBatchNormWithGlobalNormalization' operation.
    pub fn t_max(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'm' Input of this 'QuantizedBatchNormWithGlobalNormalization' operation.
    pub fn m(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'm_min' Input of this 'QuantizedBatchNormWithGlobalNormalization' operation.
    pub fn m_min(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
    /// Returns the 'm_max' Input of this 'QuantizedBatchNormWithGlobalNormalization' operation.
    pub fn m_max(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 5,
        }
    }
    /// Returns the 'v' Input of this 'QuantizedBatchNormWithGlobalNormalization' operation.
    pub fn v(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 6,
        }
    }
    /// Returns the 'v_min' Input of this 'QuantizedBatchNormWithGlobalNormalization' operation.
    pub fn v_min(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 7,
        }
    }
    /// Returns the 'v_max' Input of this 'QuantizedBatchNormWithGlobalNormalization' operation.
    pub fn v_max(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 8,
        }
    }
    /// Returns the 'beta' Input of this 'QuantizedBatchNormWithGlobalNormalization' operation.
    pub fn beta(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 9,
        }
    }
    /// Returns the 'beta_min' Input of this 'QuantizedBatchNormWithGlobalNormalization' operation.
    pub fn beta_min(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 10,
        }
    }
    /// Returns the 'beta_max' Input of this 'QuantizedBatchNormWithGlobalNormalization' operation.
    pub fn beta_max(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 11,
        }
    }
    /// Returns the 'gamma' Input of this 'QuantizedBatchNormWithGlobalNormalization' operation.
    pub fn gamma(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 12,
        }
    }
    /// Returns the 'gamma_min' Input of this 'QuantizedBatchNormWithGlobalNormalization' operation.
    pub fn gamma_min(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 13,
        }
    }
    /// Returns the 'gamma_max' Input of this 'QuantizedBatchNormWithGlobalNormalization' operation.
    pub fn gamma_max(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 14,
        }
    }
}
impl From<QuantizedBatchNormWithGlobalNormalizationInst> for crate::Operation {
    fn from(inst: QuantizedBatchNormWithGlobalNormalizationInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `QuantizedBatchNormWithGlobalNormalization::new().build(t, t_min, t_max, m, m_min, m_max, v, v_min, v_max, beta, beta_min, beta_max, gamma, gamma_min, gamma_max, scope)`.
pub fn quantized_batch_norm_with_global_normalization<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
    O6: ::std::convert::Into<crate::Output>,
    O7: ::std::convert::Into<crate::Output>,
    O8: ::std::convert::Into<crate::Output>,
    O9: ::std::convert::Into<crate::Output>,
    O10: ::std::convert::Into<crate::Output>,
    O11: ::std::convert::Into<crate::Output>,
    O12: ::std::convert::Into<crate::Output>,
    O13: ::std::convert::Into<crate::Output>,
    O14: ::std::convert::Into<crate::Output>,
>(
    t: O0,
    t_min: O1,
    t_max: O2,
    m: O3,
    m_min: O4,
    m_max: O5,
    v: O6,
    v_min: O7,
    v_max: O8,
    beta: O9,
    beta_min: O10,
    beta_max: O11,
    gamma: O12,
    gamma_min: O13,
    gamma_max: O14,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    QuantizedBatchNormWithGlobalNormalization::new().build(
        t, t_min, t_max, m, m_min, m_max, v, v_min, v_max, beta, beta_min, beta_max, gamma,
        gamma_min, gamma_max, scope,
    )
}

/// Builder for the `QuantizedBiasAdd` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct QuantizedBiasAdd {
    T1: ::std::option::Option<crate::DataType>,
    T2: ::std::option::Option<crate::DataType>,
    out_type: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'QuantizedBiasAdd' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct QuantizedBiasAddInst {
    /// An instance of a fully built QuantizedBiasAdd Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl QuantizedBiasAdd {
    /// Creates a new `QuantizedBiasAdd`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T1` attribute.
    pub fn T1<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T1 = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T2` attribute.
    pub fn T2<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T2 = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `out_type` attribute.
    pub fn out_type<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.out_type = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `QuantizedBiasAdd` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        bias: O1,
        min_input: O2,
        max_input: O3,
        min_bias: O4,
        max_bias: O5,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            input.into(),
            bias.into(),
            min_input.into(),
            max_input.into(),
            min_bias.into(),
            max_bias.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        input: crate::Output,
        bias: crate::Output,
        min_input: crate::Output,
        max_input: crate::Output,
        min_bias: crate::Output,
        max_bias: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("QuantizedBiasAdd", |nd| {
            nd.add_input(input);
            nd.add_input(bias);
            nd.add_input(min_input);
            nd.add_input(max_input);
            nd.add_input(min_bias);
            nd.add_input(max_bias);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T1 {
                nd.set_attr_type("T1", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T2 {
                nd.set_attr_type("T2", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.out_type {
                nd.set_attr_type("out_type", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'QuantizedBiasAdd' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        bias: crate::Output,
        min_input: crate::Output,
        max_input: crate::Output,
        min_bias: crate::Output,
        max_bias: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<QuantizedBiasAddInst> {
        let op = scope.new_operation("QuantizedBiasAdd", |builder| {
            builder.add_input(input);
            builder.add_input(bias);
            builder.add_input(min_input);
            builder.add_input(max_input);
            builder.add_input(min_bias);
            builder.add_input(max_bias);
            if let ::std::option::Option::Some(value) = &self.T1 {
                builder.set_attr_type("T1", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T2 {
                builder.set_attr_type("T2", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.out_type {
                builder.set_attr_type("out_type", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(QuantizedBiasAddInst { op })
    }
}
impl QuantizedBiasAddInst {
    /// Returns the 'output' Output of this 'QuantizedBiasAdd' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'min_out' Output of this 'QuantizedBiasAdd' operation.
    pub fn min_out(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'max_out' Output of this 'QuantizedBiasAdd' operation.
    pub fn max_out(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns the 'input' Input of this 'QuantizedBiasAdd' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'bias' Input of this 'QuantizedBiasAdd' operation.
    pub fn bias(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'min_input' Input of this 'QuantizedBiasAdd' operation.
    pub fn min_input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'max_input' Input of this 'QuantizedBiasAdd' operation.
    pub fn max_input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'min_bias' Input of this 'QuantizedBiasAdd' operation.
    pub fn min_bias(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
    /// Returns the 'max_bias' Input of this 'QuantizedBiasAdd' operation.
    pub fn max_bias(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 5,
        }
    }
}
impl From<QuantizedBiasAddInst> for crate::Operation {
    fn from(inst: QuantizedBiasAddInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `QuantizedBiasAdd::new().build(input, bias, min_input, max_input, min_bias, max_bias, scope)`.
pub fn quantized_bias_add<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
>(
    input: O0,
    bias: O1,
    min_input: O2,
    max_input: O3,
    min_bias: O4,
    max_bias: O5,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    QuantizedBiasAdd::new().build(input, bias, min_input, max_input, min_bias, max_bias, scope)
}

/// Builder for the `QuantizedConcat` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct QuantizedConcat {
    N: ::std::option::Option<i64>,
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'QuantizedConcat' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct QuantizedConcatInst {
    /// An instance of a fully built QuantizedConcat Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl QuantizedConcat {
    /// Creates a new `QuantizedConcat`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `N` attribute.
    pub fn N<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.N = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `QuantizedConcat` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
    >(
        &self,
        concat_dim: O0,
        values: O1,
        input_mins: O2,
        input_maxes: O3,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            concat_dim.into(),
            values.into(),
            input_mins.into(),
            input_maxes.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        concat_dim: crate::Output,
        values: crate::Output,
        input_mins: crate::Output,
        input_maxes: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("QuantizedConcat", |nd| {
            nd.add_input(concat_dim);
            nd.add_input(values);
            nd.add_input(input_mins);
            nd.add_input(input_maxes);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.N {
                nd.set_attr_int("N", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'QuantizedConcat' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        concat_dim: crate::Output,
        values: Vec<crate::Output>,
        input_mins: Vec<crate::Output>,
        input_maxes: Vec<crate::Output>,
        scope: &mut crate::Scope,
    ) -> crate::Result<QuantizedConcatInst> {
        let op = scope.new_operation("QuantizedConcat", |builder| {
            builder.add_input(concat_dim);
            builder.add_input_list(&values);
            builder.add_input_list(&input_mins);
            builder.add_input_list(&input_maxes);
            builder.set_attr_int("N", values.clone().len() as i64)?;
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(QuantizedConcatInst { op })
    }
}
impl QuantizedConcatInst {
    /// Returns the 'output' Output of this 'QuantizedConcat' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'output_min' Output of this 'QuantizedConcat' operation.
    pub fn output_min(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'output_max' Output of this 'QuantizedConcat' operation.
    pub fn output_max(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns the 'concat_dim' Input of this 'QuantizedConcat' operation.
    pub fn concat_dim(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns a Vector of values for 'values' Input of this QuantizedConcat operation.
    pub fn values(&self) -> crate::Result<Vec<crate::Input>> {
        let mut Inputs = vec![];
        for i in 1..self.op.get_attr_int("N")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
    /// Returns a Vector of input_mins for 'input_mins' Input of this QuantizedConcat operation.
    pub fn input_mins(&self) -> crate::Result<Vec<crate::Input>> {
        let dynamic_offset = (self.op.get_attr_int("N")? + 2) as i32;
        let mut Inputs = vec![];
        for i in dynamic_offset..dynamic_offset + self.op.get_attr_int("N")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
    /// Returns a Vector of input_maxes for 'input_maxes' Input of this QuantizedConcat operation.
    pub fn input_maxes(&self) -> crate::Result<Vec<crate::Input>> {
        let dynamic_offset = (2 * self.op.get_attr_int("N")? + 3) as i32;
        let mut Inputs = vec![];
        for i in dynamic_offset..dynamic_offset + self.op.get_attr_int("N")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
}
impl From<QuantizedConcatInst> for crate::Operation {
    fn from(inst: QuantizedConcatInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `QuantizedConcat::new().build(concat_dim, values, input_mins, input_maxes, scope)`.
pub fn quantized_concat<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
>(
    concat_dim: O0,
    values: O1,
    input_mins: O2,
    input_maxes: O3,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    QuantizedConcat::new().build(concat_dim, values, input_mins, input_maxes, scope)
}

/// Builder for the `QuantizedConv2D` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct QuantizedConv2D {
    Tinput: ::std::option::Option<crate::DataType>,
    Tfilter: ::std::option::Option<crate::DataType>,
    out_type: ::std::option::Option<crate::DataType>,
    strides: ::std::option::Option<::std::vec::Vec<i64>>,
    padding: ::std::option::Option<::std::string::String>,
    dilations: ::std::option::Option<::std::vec::Vec<i64>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'QuantizedConv2D' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct QuantizedConv2DInst {
    /// An instance of a fully built QuantizedConv2D Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl QuantizedConv2D {
    /// Creates a new `QuantizedConv2D`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `Tinput` attribute.
    pub fn Tinput<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tinput = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tfilter` attribute.
    pub fn Tfilter<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tfilter = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `out_type` attribute.
    pub fn out_type<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.out_type = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `strides` attribute.
    pub fn strides<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.strides = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `padding` attribute.
    pub fn padding<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.padding = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `dilations` attribute.
    pub fn dilations<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.dilations = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `QuantizedConv2D` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        filter: O1,
        min_input: O2,
        max_input: O3,
        min_filter: O4,
        max_filter: O5,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            input.into(),
            filter.into(),
            min_input.into(),
            max_input.into(),
            min_filter.into(),
            max_filter.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        input: crate::Output,
        filter: crate::Output,
        min_input: crate::Output,
        max_input: crate::Output,
        min_filter: crate::Output,
        max_filter: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("QuantizedConv2D", |nd| {
            nd.add_input(input);
            nd.add_input(filter);
            nd.add_input(min_input);
            nd.add_input(max_input);
            nd.add_input(min_filter);
            nd.add_input(max_filter);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.Tinput {
                nd.set_attr_type("Tinput", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tfilter {
                nd.set_attr_type("Tfilter", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.out_type {
                nd.set_attr_type("out_type", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.strides {
                nd.set_attr_int_list("strides", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding {
                nd.set_attr_string("padding", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dilations {
                nd.set_attr_int_list("dilations", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'QuantizedConv2D' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        filter: crate::Output,
        min_input: crate::Output,
        max_input: crate::Output,
        min_filter: crate::Output,
        max_filter: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<QuantizedConv2DInst> {
        let op = scope.new_operation("QuantizedConv2D", |builder| {
            builder.add_input(input);
            builder.add_input(filter);
            builder.add_input(min_input);
            builder.add_input(max_input);
            builder.add_input(min_filter);
            builder.add_input(max_filter);
            if let ::std::option::Option::Some(value) = &self.Tinput {
                builder.set_attr_type("Tinput", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tfilter {
                builder.set_attr_type("Tfilter", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.out_type {
                builder.set_attr_type("out_type", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.strides {
                builder.set_attr_int_list("strides", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding {
                builder.set_attr_string("padding", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dilations {
                builder.set_attr_int_list("dilations", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(QuantizedConv2DInst { op })
    }
}
impl QuantizedConv2DInst {
    /// Returns the 'output' Output of this 'QuantizedConv2D' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'min_output' Output of this 'QuantizedConv2D' operation.
    pub fn min_output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'max_output' Output of this 'QuantizedConv2D' operation.
    pub fn max_output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns the 'input' Input of this 'QuantizedConv2D' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'filter' Input of this 'QuantizedConv2D' operation.
    pub fn filter(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'min_input' Input of this 'QuantizedConv2D' operation.
    pub fn min_input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'max_input' Input of this 'QuantizedConv2D' operation.
    pub fn max_input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'min_filter' Input of this 'QuantizedConv2D' operation.
    pub fn min_filter(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
    /// Returns the 'max_filter' Input of this 'QuantizedConv2D' operation.
    pub fn max_filter(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 5,
        }
    }
}
impl From<QuantizedConv2DInst> for crate::Operation {
    fn from(inst: QuantizedConv2DInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `QuantizedConv2D::new().build(input, filter, min_input, max_input, min_filter, max_filter, scope)`.
pub fn quantized_conv2_d<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
>(
    input: O0,
    filter: O1,
    min_input: O2,
    max_input: O3,
    min_filter: O4,
    max_filter: O5,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    QuantizedConv2D::new().build(
        input, filter, min_input, max_input, min_filter, max_filter, scope,
    )
}

/// Builder for the `QuantizedConv2DAndRelu` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct QuantizedConv2DAndRelu {
    Tinput: ::std::option::Option<crate::DataType>,
    Tfilter: ::std::option::Option<crate::DataType>,
    out_type: ::std::option::Option<crate::DataType>,
    strides: ::std::option::Option<::std::vec::Vec<i64>>,
    padding: ::std::option::Option<::std::string::String>,
    dilations: ::std::option::Option<::std::vec::Vec<i64>>,
    padding_list: ::std::option::Option<::std::vec::Vec<i64>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'QuantizedConv2DAndRelu' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct QuantizedConv2DAndReluInst {
    /// An instance of a fully built QuantizedConv2DAndRelu Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl QuantizedConv2DAndRelu {
    /// Creates a new `QuantizedConv2DAndRelu`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `Tinput` attribute.
    pub fn Tinput<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tinput = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tfilter` attribute.
    pub fn Tfilter<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tfilter = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `out_type` attribute.
    pub fn out_type<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.out_type = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `strides` attribute.
    pub fn strides<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.strides = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `padding` attribute.
    pub fn padding<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.padding = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `dilations` attribute.
    pub fn dilations<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.dilations = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `padding_list` attribute.
    pub fn padding_list<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.padding_list = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `QuantizedConv2DAndRelu` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        filter: O1,
        min_input: O2,
        max_input: O3,
        min_filter: O4,
        max_filter: O5,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            input.into(),
            filter.into(),
            min_input.into(),
            max_input.into(),
            min_filter.into(),
            max_filter.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        input: crate::Output,
        filter: crate::Output,
        min_input: crate::Output,
        max_input: crate::Output,
        min_filter: crate::Output,
        max_filter: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("QuantizedConv2DAndRelu", |nd| {
            nd.add_input(input);
            nd.add_input(filter);
            nd.add_input(min_input);
            nd.add_input(max_input);
            nd.add_input(min_filter);
            nd.add_input(max_filter);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.Tinput {
                nd.set_attr_type("Tinput", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tfilter {
                nd.set_attr_type("Tfilter", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.out_type {
                nd.set_attr_type("out_type", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.strides {
                nd.set_attr_int_list("strides", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding {
                nd.set_attr_string("padding", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dilations {
                nd.set_attr_int_list("dilations", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding_list {
                nd.set_attr_int_list("padding_list", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'QuantizedConv2DAndRelu' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        filter: crate::Output,
        min_input: crate::Output,
        max_input: crate::Output,
        min_filter: crate::Output,
        max_filter: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<QuantizedConv2DAndReluInst> {
        let op = scope.new_operation("QuantizedConv2DAndRelu", |builder| {
            builder.add_input(input);
            builder.add_input(filter);
            builder.add_input(min_input);
            builder.add_input(max_input);
            builder.add_input(min_filter);
            builder.add_input(max_filter);
            if let ::std::option::Option::Some(value) = &self.Tinput {
                builder.set_attr_type("Tinput", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tfilter {
                builder.set_attr_type("Tfilter", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.out_type {
                builder.set_attr_type("out_type", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.strides {
                builder.set_attr_int_list("strides", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding {
                builder.set_attr_string("padding", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dilations {
                builder.set_attr_int_list("dilations", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding_list {
                builder.set_attr_int_list("padding_list", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(QuantizedConv2DAndReluInst { op })
    }
}
impl QuantizedConv2DAndReluInst {
    /// Returns the 'output' Output of this 'QuantizedConv2DAndRelu' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'min_output' Output of this 'QuantizedConv2DAndRelu' operation.
    pub fn min_output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'max_output' Output of this 'QuantizedConv2DAndRelu' operation.
    pub fn max_output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns the 'input' Input of this 'QuantizedConv2DAndRelu' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'filter' Input of this 'QuantizedConv2DAndRelu' operation.
    pub fn filter(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'min_input' Input of this 'QuantizedConv2DAndRelu' operation.
    pub fn min_input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'max_input' Input of this 'QuantizedConv2DAndRelu' operation.
    pub fn max_input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'min_filter' Input of this 'QuantizedConv2DAndRelu' operation.
    pub fn min_filter(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
    /// Returns the 'max_filter' Input of this 'QuantizedConv2DAndRelu' operation.
    pub fn max_filter(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 5,
        }
    }
}
impl From<QuantizedConv2DAndReluInst> for crate::Operation {
    fn from(inst: QuantizedConv2DAndReluInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `QuantizedConv2DAndRelu::new().build(input, filter, min_input, max_input, min_filter, max_filter, scope)`.
pub fn quantized_conv2_dand_relu<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
>(
    input: O0,
    filter: O1,
    min_input: O2,
    max_input: O3,
    min_filter: O4,
    max_filter: O5,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    QuantizedConv2DAndRelu::new().build(
        input, filter, min_input, max_input, min_filter, max_filter, scope,
    )
}

/// Builder for the `QuantizedConv2DAndReluAndRequantize` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct QuantizedConv2DAndReluAndRequantize {
    Tinput: ::std::option::Option<crate::DataType>,
    Tfilter: ::std::option::Option<crate::DataType>,
    out_type: ::std::option::Option<crate::DataType>,
    strides: ::std::option::Option<::std::vec::Vec<i64>>,
    padding: ::std::option::Option<::std::string::String>,
    dilations: ::std::option::Option<::std::vec::Vec<i64>>,
    padding_list: ::std::option::Option<::std::vec::Vec<i64>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'QuantizedConv2DAndReluAndRequantize' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct QuantizedConv2DAndReluAndRequantizeInst {
    /// An instance of a fully built QuantizedConv2DAndReluAndRequantize Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl QuantizedConv2DAndReluAndRequantize {
    /// Creates a new `QuantizedConv2DAndReluAndRequantize`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `Tinput` attribute.
    pub fn Tinput<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tinput = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tfilter` attribute.
    pub fn Tfilter<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tfilter = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `out_type` attribute.
    pub fn out_type<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.out_type = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `strides` attribute.
    pub fn strides<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.strides = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `padding` attribute.
    pub fn padding<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.padding = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `dilations` attribute.
    pub fn dilations<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.dilations = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `padding_list` attribute.
    pub fn padding_list<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.padding_list = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `QuantizedConv2DAndReluAndRequantize` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
        O6: ::std::convert::Into<crate::Output>,
        O7: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        filter: O1,
        min_input: O2,
        max_input: O3,
        min_filter: O4,
        max_filter: O5,
        min_freezed_output: O6,
        max_freezed_output: O7,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            input.into(),
            filter.into(),
            min_input.into(),
            max_input.into(),
            min_filter.into(),
            max_filter.into(),
            min_freezed_output.into(),
            max_freezed_output.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        input: crate::Output,
        filter: crate::Output,
        min_input: crate::Output,
        max_input: crate::Output,
        min_filter: crate::Output,
        max_filter: crate::Output,
        min_freezed_output: crate::Output,
        max_freezed_output: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("QuantizedConv2DAndReluAndRequantize", |nd| {
            nd.add_input(input);
            nd.add_input(filter);
            nd.add_input(min_input);
            nd.add_input(max_input);
            nd.add_input(min_filter);
            nd.add_input(max_filter);
            nd.add_input(min_freezed_output);
            nd.add_input(max_freezed_output);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.Tinput {
                nd.set_attr_type("Tinput", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tfilter {
                nd.set_attr_type("Tfilter", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.out_type {
                nd.set_attr_type("out_type", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.strides {
                nd.set_attr_int_list("strides", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding {
                nd.set_attr_string("padding", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dilations {
                nd.set_attr_int_list("dilations", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding_list {
                nd.set_attr_int_list("padding_list", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'QuantizedConv2DAndReluAndRequantize' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        filter: crate::Output,
        min_input: crate::Output,
        max_input: crate::Output,
        min_filter: crate::Output,
        max_filter: crate::Output,
        min_freezed_output: crate::Output,
        max_freezed_output: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<QuantizedConv2DAndReluAndRequantizeInst> {
        let op = scope.new_operation("QuantizedConv2DAndReluAndRequantize", |builder| {
            builder.add_input(input);
            builder.add_input(filter);
            builder.add_input(min_input);
            builder.add_input(max_input);
            builder.add_input(min_filter);
            builder.add_input(max_filter);
            builder.add_input(min_freezed_output);
            builder.add_input(max_freezed_output);
            if let ::std::option::Option::Some(value) = &self.Tinput {
                builder.set_attr_type("Tinput", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tfilter {
                builder.set_attr_type("Tfilter", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.out_type {
                builder.set_attr_type("out_type", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.strides {
                builder.set_attr_int_list("strides", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding {
                builder.set_attr_string("padding", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dilations {
                builder.set_attr_int_list("dilations", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding_list {
                builder.set_attr_int_list("padding_list", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(QuantizedConv2DAndReluAndRequantizeInst { op })
    }
}
impl QuantizedConv2DAndReluAndRequantizeInst {
    /// Returns the 'output' Output of this 'QuantizedConv2DAndReluAndRequantize' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'min_output' Output of this 'QuantizedConv2DAndReluAndRequantize' operation.
    pub fn min_output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'max_output' Output of this 'QuantizedConv2DAndReluAndRequantize' operation.
    pub fn max_output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns the 'input' Input of this 'QuantizedConv2DAndReluAndRequantize' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'filter' Input of this 'QuantizedConv2DAndReluAndRequantize' operation.
    pub fn filter(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'min_input' Input of this 'QuantizedConv2DAndReluAndRequantize' operation.
    pub fn min_input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'max_input' Input of this 'QuantizedConv2DAndReluAndRequantize' operation.
    pub fn max_input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'min_filter' Input of this 'QuantizedConv2DAndReluAndRequantize' operation.
    pub fn min_filter(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
    /// Returns the 'max_filter' Input of this 'QuantizedConv2DAndReluAndRequantize' operation.
    pub fn max_filter(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 5,
        }
    }
    /// Returns the 'min_freezed_output' Input of this 'QuantizedConv2DAndReluAndRequantize' operation.
    pub fn min_freezed_output(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 6,
        }
    }
    /// Returns the 'max_freezed_output' Input of this 'QuantizedConv2DAndReluAndRequantize' operation.
    pub fn max_freezed_output(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 7,
        }
    }
}
impl From<QuantizedConv2DAndReluAndRequantizeInst> for crate::Operation {
    fn from(inst: QuantizedConv2DAndReluAndRequantizeInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `QuantizedConv2DAndReluAndRequantize::new().build(input, filter, min_input, max_input, min_filter, max_filter, min_freezed_output, max_freezed_output, scope)`.
pub fn quantized_conv2_dand_relu_and_requantize<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
    O6: ::std::convert::Into<crate::Output>,
    O7: ::std::convert::Into<crate::Output>,
>(
    input: O0,
    filter: O1,
    min_input: O2,
    max_input: O3,
    min_filter: O4,
    max_filter: O5,
    min_freezed_output: O6,
    max_freezed_output: O7,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    QuantizedConv2DAndReluAndRequantize::new().build(
        input,
        filter,
        min_input,
        max_input,
        min_filter,
        max_filter,
        min_freezed_output,
        max_freezed_output,
        scope,
    )
}

/// Builder for the `QuantizedConv2DAndRequantize` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct QuantizedConv2DAndRequantize {
    Tinput: ::std::option::Option<crate::DataType>,
    Tfilter: ::std::option::Option<crate::DataType>,
    out_type: ::std::option::Option<crate::DataType>,
    strides: ::std::option::Option<::std::vec::Vec<i64>>,
    padding: ::std::option::Option<::std::string::String>,
    dilations: ::std::option::Option<::std::vec::Vec<i64>>,
    padding_list: ::std::option::Option<::std::vec::Vec<i64>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'QuantizedConv2DAndRequantize' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct QuantizedConv2DAndRequantizeInst {
    /// An instance of a fully built QuantizedConv2DAndRequantize Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl QuantizedConv2DAndRequantize {
    /// Creates a new `QuantizedConv2DAndRequantize`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `Tinput` attribute.
    pub fn Tinput<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tinput = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tfilter` attribute.
    pub fn Tfilter<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tfilter = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `out_type` attribute.
    pub fn out_type<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.out_type = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `strides` attribute.
    pub fn strides<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.strides = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `padding` attribute.
    pub fn padding<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.padding = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `dilations` attribute.
    pub fn dilations<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.dilations = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `padding_list` attribute.
    pub fn padding_list<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.padding_list = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `QuantizedConv2DAndRequantize` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
        O6: ::std::convert::Into<crate::Output>,
        O7: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        filter: O1,
        min_input: O2,
        max_input: O3,
        min_filter: O4,
        max_filter: O5,
        min_freezed_output: O6,
        max_freezed_output: O7,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            input.into(),
            filter.into(),
            min_input.into(),
            max_input.into(),
            min_filter.into(),
            max_filter.into(),
            min_freezed_output.into(),
            max_freezed_output.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        input: crate::Output,
        filter: crate::Output,
        min_input: crate::Output,
        max_input: crate::Output,
        min_filter: crate::Output,
        max_filter: crate::Output,
        min_freezed_output: crate::Output,
        max_freezed_output: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("QuantizedConv2DAndRequantize", |nd| {
            nd.add_input(input);
            nd.add_input(filter);
            nd.add_input(min_input);
            nd.add_input(max_input);
            nd.add_input(min_filter);
            nd.add_input(max_filter);
            nd.add_input(min_freezed_output);
            nd.add_input(max_freezed_output);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.Tinput {
                nd.set_attr_type("Tinput", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tfilter {
                nd.set_attr_type("Tfilter", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.out_type {
                nd.set_attr_type("out_type", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.strides {
                nd.set_attr_int_list("strides", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding {
                nd.set_attr_string("padding", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dilations {
                nd.set_attr_int_list("dilations", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding_list {
                nd.set_attr_int_list("padding_list", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'QuantizedConv2DAndRequantize' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        filter: crate::Output,
        min_input: crate::Output,
        max_input: crate::Output,
        min_filter: crate::Output,
        max_filter: crate::Output,
        min_freezed_output: crate::Output,
        max_freezed_output: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<QuantizedConv2DAndRequantizeInst> {
        let op = scope.new_operation("QuantizedConv2DAndRequantize", |builder| {
            builder.add_input(input);
            builder.add_input(filter);
            builder.add_input(min_input);
            builder.add_input(max_input);
            builder.add_input(min_filter);
            builder.add_input(max_filter);
            builder.add_input(min_freezed_output);
            builder.add_input(max_freezed_output);
            if let ::std::option::Option::Some(value) = &self.Tinput {
                builder.set_attr_type("Tinput", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tfilter {
                builder.set_attr_type("Tfilter", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.out_type {
                builder.set_attr_type("out_type", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.strides {
                builder.set_attr_int_list("strides", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding {
                builder.set_attr_string("padding", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dilations {
                builder.set_attr_int_list("dilations", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding_list {
                builder.set_attr_int_list("padding_list", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(QuantizedConv2DAndRequantizeInst { op })
    }
}
impl QuantizedConv2DAndRequantizeInst {
    /// Returns the 'output' Output of this 'QuantizedConv2DAndRequantize' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'min_output' Output of this 'QuantizedConv2DAndRequantize' operation.
    pub fn min_output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'max_output' Output of this 'QuantizedConv2DAndRequantize' operation.
    pub fn max_output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns the 'input' Input of this 'QuantizedConv2DAndRequantize' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'filter' Input of this 'QuantizedConv2DAndRequantize' operation.
    pub fn filter(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'min_input' Input of this 'QuantizedConv2DAndRequantize' operation.
    pub fn min_input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'max_input' Input of this 'QuantizedConv2DAndRequantize' operation.
    pub fn max_input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'min_filter' Input of this 'QuantizedConv2DAndRequantize' operation.
    pub fn min_filter(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
    /// Returns the 'max_filter' Input of this 'QuantizedConv2DAndRequantize' operation.
    pub fn max_filter(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 5,
        }
    }
    /// Returns the 'min_freezed_output' Input of this 'QuantizedConv2DAndRequantize' operation.
    pub fn min_freezed_output(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 6,
        }
    }
    /// Returns the 'max_freezed_output' Input of this 'QuantizedConv2DAndRequantize' operation.
    pub fn max_freezed_output(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 7,
        }
    }
}
impl From<QuantizedConv2DAndRequantizeInst> for crate::Operation {
    fn from(inst: QuantizedConv2DAndRequantizeInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `QuantizedConv2DAndRequantize::new().build(input, filter, min_input, max_input, min_filter, max_filter, min_freezed_output, max_freezed_output, scope)`.
pub fn quantized_conv2_dand_requantize<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
    O6: ::std::convert::Into<crate::Output>,
    O7: ::std::convert::Into<crate::Output>,
>(
    input: O0,
    filter: O1,
    min_input: O2,
    max_input: O3,
    min_filter: O4,
    max_filter: O5,
    min_freezed_output: O6,
    max_freezed_output: O7,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    QuantizedConv2DAndRequantize::new().build(
        input,
        filter,
        min_input,
        max_input,
        min_filter,
        max_filter,
        min_freezed_output,
        max_freezed_output,
        scope,
    )
}

/// Builder for the `QuantizedConv2DPerChannel` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct QuantizedConv2DPerChannel {
    Tinput: ::std::option::Option<crate::DataType>,
    Tfilter: ::std::option::Option<crate::DataType>,
    out_type: ::std::option::Option<crate::DataType>,
    strides: ::std::option::Option<::std::vec::Vec<i64>>,
    padding: ::std::option::Option<::std::string::String>,
    dilations: ::std::option::Option<::std::vec::Vec<i64>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'QuantizedConv2DPerChannel' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct QuantizedConv2DPerChannelInst {
    /// An instance of a fully built QuantizedConv2DPerChannel Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl QuantizedConv2DPerChannel {
    /// Creates a new `QuantizedConv2DPerChannel`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `Tinput` attribute.
    pub fn Tinput<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tinput = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tfilter` attribute.
    pub fn Tfilter<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tfilter = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `out_type` attribute.
    pub fn out_type<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.out_type = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `strides` attribute.
    pub fn strides<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.strides = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `padding` attribute.
    pub fn padding<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.padding = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `dilations` attribute.
    pub fn dilations<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.dilations = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `QuantizedConv2DPerChannel` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        filter: O1,
        min_input: O2,
        max_input: O3,
        min_filter: O4,
        max_filter: O5,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            input.into(),
            filter.into(),
            min_input.into(),
            max_input.into(),
            min_filter.into(),
            max_filter.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        input: crate::Output,
        filter: crate::Output,
        min_input: crate::Output,
        max_input: crate::Output,
        min_filter: crate::Output,
        max_filter: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("QuantizedConv2DPerChannel", |nd| {
            nd.add_input(input);
            nd.add_input(filter);
            nd.add_input(min_input);
            nd.add_input(max_input);
            nd.add_input(min_filter);
            nd.add_input(max_filter);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.Tinput {
                nd.set_attr_type("Tinput", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tfilter {
                nd.set_attr_type("Tfilter", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.out_type {
                nd.set_attr_type("out_type", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.strides {
                nd.set_attr_int_list("strides", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding {
                nd.set_attr_string("padding", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dilations {
                nd.set_attr_int_list("dilations", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'QuantizedConv2DPerChannel' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        filter: crate::Output,
        min_input: crate::Output,
        max_input: crate::Output,
        min_filter: crate::Output,
        max_filter: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<QuantizedConv2DPerChannelInst> {
        let op = scope.new_operation("QuantizedConv2DPerChannel", |builder| {
            builder.add_input(input);
            builder.add_input(filter);
            builder.add_input(min_input);
            builder.add_input(max_input);
            builder.add_input(min_filter);
            builder.add_input(max_filter);
            if let ::std::option::Option::Some(value) = &self.Tinput {
                builder.set_attr_type("Tinput", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tfilter {
                builder.set_attr_type("Tfilter", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.out_type {
                builder.set_attr_type("out_type", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.strides {
                builder.set_attr_int_list("strides", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding {
                builder.set_attr_string("padding", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dilations {
                builder.set_attr_int_list("dilations", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(QuantizedConv2DPerChannelInst { op })
    }
}
impl QuantizedConv2DPerChannelInst {
    /// Returns the 'output' Output of this 'QuantizedConv2DPerChannel' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'min_output' Output of this 'QuantizedConv2DPerChannel' operation.
    pub fn min_output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'max_output' Output of this 'QuantizedConv2DPerChannel' operation.
    pub fn max_output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns the 'input' Input of this 'QuantizedConv2DPerChannel' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'filter' Input of this 'QuantizedConv2DPerChannel' operation.
    pub fn filter(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'min_input' Input of this 'QuantizedConv2DPerChannel' operation.
    pub fn min_input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'max_input' Input of this 'QuantizedConv2DPerChannel' operation.
    pub fn max_input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'min_filter' Input of this 'QuantizedConv2DPerChannel' operation.
    pub fn min_filter(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
    /// Returns the 'max_filter' Input of this 'QuantizedConv2DPerChannel' operation.
    pub fn max_filter(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 5,
        }
    }
}
impl From<QuantizedConv2DPerChannelInst> for crate::Operation {
    fn from(inst: QuantizedConv2DPerChannelInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `QuantizedConv2DPerChannel::new().build(input, filter, min_input, max_input, min_filter, max_filter, scope)`.
pub fn quantized_conv2_dper_channel<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
>(
    input: O0,
    filter: O1,
    min_input: O2,
    max_input: O3,
    min_filter: O4,
    max_filter: O5,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    QuantizedConv2DPerChannel::new().build(
        input, filter, min_input, max_input, min_filter, max_filter, scope,
    )
}

/// Builder for the `QuantizedConv2DWithBias` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct QuantizedConv2DWithBias {
    Tinput: ::std::option::Option<crate::DataType>,
    Tfilter: ::std::option::Option<crate::DataType>,
    out_type: ::std::option::Option<crate::DataType>,
    strides: ::std::option::Option<::std::vec::Vec<i64>>,
    padding: ::std::option::Option<::std::string::String>,
    dilations: ::std::option::Option<::std::vec::Vec<i64>>,
    padding_list: ::std::option::Option<::std::vec::Vec<i64>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'QuantizedConv2DWithBias' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct QuantizedConv2DWithBiasInst {
    /// An instance of a fully built QuantizedConv2DWithBias Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl QuantizedConv2DWithBias {
    /// Creates a new `QuantizedConv2DWithBias`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `Tinput` attribute.
    pub fn Tinput<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tinput = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tfilter` attribute.
    pub fn Tfilter<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tfilter = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `out_type` attribute.
    pub fn out_type<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.out_type = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `strides` attribute.
    pub fn strides<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.strides = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `padding` attribute.
    pub fn padding<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.padding = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `dilations` attribute.
    pub fn dilations<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.dilations = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `padding_list` attribute.
    pub fn padding_list<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.padding_list = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `QuantizedConv2DWithBias` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
        O6: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        filter: O1,
        bias: O2,
        min_input: O3,
        max_input: O4,
        min_filter: O5,
        max_filter: O6,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            input.into(),
            filter.into(),
            bias.into(),
            min_input.into(),
            max_input.into(),
            min_filter.into(),
            max_filter.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        input: crate::Output,
        filter: crate::Output,
        bias: crate::Output,
        min_input: crate::Output,
        max_input: crate::Output,
        min_filter: crate::Output,
        max_filter: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("QuantizedConv2DWithBias", |nd| {
            nd.add_input(input);
            nd.add_input(filter);
            nd.add_input(bias);
            nd.add_input(min_input);
            nd.add_input(max_input);
            nd.add_input(min_filter);
            nd.add_input(max_filter);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.Tinput {
                nd.set_attr_type("Tinput", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tfilter {
                nd.set_attr_type("Tfilter", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.out_type {
                nd.set_attr_type("out_type", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.strides {
                nd.set_attr_int_list("strides", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding {
                nd.set_attr_string("padding", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dilations {
                nd.set_attr_int_list("dilations", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding_list {
                nd.set_attr_int_list("padding_list", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'QuantizedConv2DWithBias' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        filter: crate::Output,
        bias: crate::Output,
        min_input: crate::Output,
        max_input: crate::Output,
        min_filter: crate::Output,
        max_filter: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<QuantizedConv2DWithBiasInst> {
        let op = scope.new_operation("QuantizedConv2DWithBias", |builder| {
            builder.add_input(input);
            builder.add_input(filter);
            builder.add_input(bias);
            builder.add_input(min_input);
            builder.add_input(max_input);
            builder.add_input(min_filter);
            builder.add_input(max_filter);
            if let ::std::option::Option::Some(value) = &self.Tinput {
                builder.set_attr_type("Tinput", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tfilter {
                builder.set_attr_type("Tfilter", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.out_type {
                builder.set_attr_type("out_type", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.strides {
                builder.set_attr_int_list("strides", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding {
                builder.set_attr_string("padding", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dilations {
                builder.set_attr_int_list("dilations", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding_list {
                builder.set_attr_int_list("padding_list", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(QuantizedConv2DWithBiasInst { op })
    }
}
impl QuantizedConv2DWithBiasInst {
    /// Returns the 'output' Output of this 'QuantizedConv2DWithBias' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'min_output' Output of this 'QuantizedConv2DWithBias' operation.
    pub fn min_output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'max_output' Output of this 'QuantizedConv2DWithBias' operation.
    pub fn max_output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns the 'input' Input of this 'QuantizedConv2DWithBias' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'filter' Input of this 'QuantizedConv2DWithBias' operation.
    pub fn filter(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'bias' Input of this 'QuantizedConv2DWithBias' operation.
    pub fn bias(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'min_input' Input of this 'QuantizedConv2DWithBias' operation.
    pub fn min_input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'max_input' Input of this 'QuantizedConv2DWithBias' operation.
    pub fn max_input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
    /// Returns the 'min_filter' Input of this 'QuantizedConv2DWithBias' operation.
    pub fn min_filter(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 5,
        }
    }
    /// Returns the 'max_filter' Input of this 'QuantizedConv2DWithBias' operation.
    pub fn max_filter(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 6,
        }
    }
}
impl From<QuantizedConv2DWithBiasInst> for crate::Operation {
    fn from(inst: QuantizedConv2DWithBiasInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `QuantizedConv2DWithBias::new().build(input, filter, bias, min_input, max_input, min_filter, max_filter, scope)`.
pub fn quantized_conv2_dwith_bias<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
    O6: ::std::convert::Into<crate::Output>,
>(
    input: O0,
    filter: O1,
    bias: O2,
    min_input: O3,
    max_input: O4,
    min_filter: O5,
    max_filter: O6,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    QuantizedConv2DWithBias::new().build(
        input, filter, bias, min_input, max_input, min_filter, max_filter, scope,
    )
}

/// Builder for the `QuantizedConv2DWithBiasAndRelu` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct QuantizedConv2DWithBiasAndRelu {
    Tinput: ::std::option::Option<crate::DataType>,
    Tfilter: ::std::option::Option<crate::DataType>,
    out_type: ::std::option::Option<crate::DataType>,
    strides: ::std::option::Option<::std::vec::Vec<i64>>,
    padding: ::std::option::Option<::std::string::String>,
    dilations: ::std::option::Option<::std::vec::Vec<i64>>,
    padding_list: ::std::option::Option<::std::vec::Vec<i64>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'QuantizedConv2DWithBiasAndRelu' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct QuantizedConv2DWithBiasAndReluInst {
    /// An instance of a fully built QuantizedConv2DWithBiasAndRelu Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl QuantizedConv2DWithBiasAndRelu {
    /// Creates a new `QuantizedConv2DWithBiasAndRelu`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `Tinput` attribute.
    pub fn Tinput<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tinput = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tfilter` attribute.
    pub fn Tfilter<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tfilter = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `out_type` attribute.
    pub fn out_type<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.out_type = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `strides` attribute.
    pub fn strides<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.strides = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `padding` attribute.
    pub fn padding<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.padding = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `dilations` attribute.
    pub fn dilations<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.dilations = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `padding_list` attribute.
    pub fn padding_list<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.padding_list = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `QuantizedConv2DWithBiasAndRelu` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
        O6: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        filter: O1,
        bias: O2,
        min_input: O3,
        max_input: O4,
        min_filter: O5,
        max_filter: O6,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            input.into(),
            filter.into(),
            bias.into(),
            min_input.into(),
            max_input.into(),
            min_filter.into(),
            max_filter.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        input: crate::Output,
        filter: crate::Output,
        bias: crate::Output,
        min_input: crate::Output,
        max_input: crate::Output,
        min_filter: crate::Output,
        max_filter: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("QuantizedConv2DWithBiasAndRelu", |nd| {
            nd.add_input(input);
            nd.add_input(filter);
            nd.add_input(bias);
            nd.add_input(min_input);
            nd.add_input(max_input);
            nd.add_input(min_filter);
            nd.add_input(max_filter);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.Tinput {
                nd.set_attr_type("Tinput", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tfilter {
                nd.set_attr_type("Tfilter", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.out_type {
                nd.set_attr_type("out_type", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.strides {
                nd.set_attr_int_list("strides", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding {
                nd.set_attr_string("padding", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dilations {
                nd.set_attr_int_list("dilations", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding_list {
                nd.set_attr_int_list("padding_list", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'QuantizedConv2DWithBiasAndRelu' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        filter: crate::Output,
        bias: crate::Output,
        min_input: crate::Output,
        max_input: crate::Output,
        min_filter: crate::Output,
        max_filter: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<QuantizedConv2DWithBiasAndReluInst> {
        let op = scope.new_operation("QuantizedConv2DWithBiasAndRelu", |builder| {
            builder.add_input(input);
            builder.add_input(filter);
            builder.add_input(bias);
            builder.add_input(min_input);
            builder.add_input(max_input);
            builder.add_input(min_filter);
            builder.add_input(max_filter);
            if let ::std::option::Option::Some(value) = &self.Tinput {
                builder.set_attr_type("Tinput", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tfilter {
                builder.set_attr_type("Tfilter", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.out_type {
                builder.set_attr_type("out_type", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.strides {
                builder.set_attr_int_list("strides", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding {
                builder.set_attr_string("padding", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dilations {
                builder.set_attr_int_list("dilations", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding_list {
                builder.set_attr_int_list("padding_list", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(QuantizedConv2DWithBiasAndReluInst { op })
    }
}
impl QuantizedConv2DWithBiasAndReluInst {
    /// Returns the 'output' Output of this 'QuantizedConv2DWithBiasAndRelu' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'min_output' Output of this 'QuantizedConv2DWithBiasAndRelu' operation.
    pub fn min_output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'max_output' Output of this 'QuantizedConv2DWithBiasAndRelu' operation.
    pub fn max_output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns the 'input' Input of this 'QuantizedConv2DWithBiasAndRelu' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'filter' Input of this 'QuantizedConv2DWithBiasAndRelu' operation.
    pub fn filter(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'bias' Input of this 'QuantizedConv2DWithBiasAndRelu' operation.
    pub fn bias(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'min_input' Input of this 'QuantizedConv2DWithBiasAndRelu' operation.
    pub fn min_input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'max_input' Input of this 'QuantizedConv2DWithBiasAndRelu' operation.
    pub fn max_input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
    /// Returns the 'min_filter' Input of this 'QuantizedConv2DWithBiasAndRelu' operation.
    pub fn min_filter(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 5,
        }
    }
    /// Returns the 'max_filter' Input of this 'QuantizedConv2DWithBiasAndRelu' operation.
    pub fn max_filter(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 6,
        }
    }
}
impl From<QuantizedConv2DWithBiasAndReluInst> for crate::Operation {
    fn from(inst: QuantizedConv2DWithBiasAndReluInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `QuantizedConv2DWithBiasAndRelu::new().build(input, filter, bias, min_input, max_input, min_filter, max_filter, scope)`.
pub fn quantized_conv2_dwith_bias_and_relu<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
    O6: ::std::convert::Into<crate::Output>,
>(
    input: O0,
    filter: O1,
    bias: O2,
    min_input: O3,
    max_input: O4,
    min_filter: O5,
    max_filter: O6,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    QuantizedConv2DWithBiasAndRelu::new().build(
        input, filter, bias, min_input, max_input, min_filter, max_filter, scope,
    )
}

/// Builder for the `QuantizedConv2DWithBiasAndReluAndRequantize` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct QuantizedConv2DWithBiasAndReluAndRequantize {
    Tinput: ::std::option::Option<crate::DataType>,
    Tfilter: ::std::option::Option<crate::DataType>,
    Tbias: ::std::option::Option<crate::DataType>,
    out_type: ::std::option::Option<crate::DataType>,
    strides: ::std::option::Option<::std::vec::Vec<i64>>,
    padding: ::std::option::Option<::std::string::String>,
    dilations: ::std::option::Option<::std::vec::Vec<i64>>,
    padding_list: ::std::option::Option<::std::vec::Vec<i64>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'QuantizedConv2DWithBiasAndReluAndRequantize' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct QuantizedConv2DWithBiasAndReluAndRequantizeInst {
    /// An instance of a fully built QuantizedConv2DWithBiasAndReluAndRequantize Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl QuantizedConv2DWithBiasAndReluAndRequantize {
    /// Creates a new `QuantizedConv2DWithBiasAndReluAndRequantize`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `Tinput` attribute.
    pub fn Tinput<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tinput = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tfilter` attribute.
    pub fn Tfilter<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tfilter = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tbias` attribute.
    pub fn Tbias<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Tbias = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `out_type` attribute.
    pub fn out_type<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.out_type = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `strides` attribute.
    pub fn strides<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.strides = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `padding` attribute.
    pub fn padding<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.padding = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `dilations` attribute.
    pub fn dilations<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.dilations = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `padding_list` attribute.
    pub fn padding_list<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.padding_list = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `QuantizedConv2DWithBiasAndReluAndRequantize` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
        O6: ::std::convert::Into<crate::Output>,
        O7: ::std::convert::Into<crate::Output>,
        O8: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        filter: O1,
        bias: O2,
        min_input: O3,
        max_input: O4,
        min_filter: O5,
        max_filter: O6,
        min_freezed_output: O7,
        max_freezed_output: O8,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            input.into(),
            filter.into(),
            bias.into(),
            min_input.into(),
            max_input.into(),
            min_filter.into(),
            max_filter.into(),
            min_freezed_output.into(),
            max_freezed_output.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        input: crate::Output,
        filter: crate::Output,
        bias: crate::Output,
        min_input: crate::Output,
        max_input: crate::Output,
        min_filter: crate::Output,
        max_filter: crate::Output,
        min_freezed_output: crate::Output,
        max_freezed_output: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("QuantizedConv2DWithBiasAndReluAndRequantize", |nd| {
            nd.add_input(input);
            nd.add_input(filter);
            nd.add_input(bias);
            nd.add_input(min_input);
            nd.add_input(max_input);
            nd.add_input(min_filter);
            nd.add_input(max_filter);
            nd.add_input(min_freezed_output);
            nd.add_input(max_freezed_output);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.Tinput {
                nd.set_attr_type("Tinput", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tfilter {
                nd.set_attr_type("Tfilter", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tbias {
                nd.set_attr_type("Tbias", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.out_type {
                nd.set_attr_type("out_type", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.strides {
                nd.set_attr_int_list("strides", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding {
                nd.set_attr_string("padding", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dilations {
                nd.set_attr_int_list("dilations", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding_list {
                nd.set_attr_int_list("padding_list", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'QuantizedConv2DWithBiasAndReluAndRequantize' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        filter: crate::Output,
        bias: crate::Output,
        min_input: crate::Output,
        max_input: crate::Output,
        min_filter: crate::Output,
        max_filter: crate::Output,
        min_freezed_output: crate::Output,
        max_freezed_output: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<QuantizedConv2DWithBiasAndReluAndRequantizeInst> {
        let op = scope.new_operation("QuantizedConv2DWithBiasAndReluAndRequantize", |builder| {
            builder.add_input(input);
            builder.add_input(filter);
            builder.add_input(bias);
            builder.add_input(min_input);
            builder.add_input(max_input);
            builder.add_input(min_filter);
            builder.add_input(max_filter);
            builder.add_input(min_freezed_output);
            builder.add_input(max_freezed_output);
            if let ::std::option::Option::Some(value) = &self.Tinput {
                builder.set_attr_type("Tinput", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tfilter {
                builder.set_attr_type("Tfilter", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tbias {
                builder.set_attr_type("Tbias", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.out_type {
                builder.set_attr_type("out_type", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.strides {
                builder.set_attr_int_list("strides", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding {
                builder.set_attr_string("padding", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dilations {
                builder.set_attr_int_list("dilations", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding_list {
                builder.set_attr_int_list("padding_list", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(QuantizedConv2DWithBiasAndReluAndRequantizeInst { op })
    }
}
impl QuantizedConv2DWithBiasAndReluAndRequantizeInst {
    /// Returns the 'output' Output of this 'QuantizedConv2DWithBiasAndReluAndRequantize' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'min_output' Output of this 'QuantizedConv2DWithBiasAndReluAndRequantize' operation.
    pub fn min_output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'max_output' Output of this 'QuantizedConv2DWithBiasAndReluAndRequantize' operation.
    pub fn max_output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns the 'input' Input of this 'QuantizedConv2DWithBiasAndReluAndRequantize' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'filter' Input of this 'QuantizedConv2DWithBiasAndReluAndRequantize' operation.
    pub fn filter(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'bias' Input of this 'QuantizedConv2DWithBiasAndReluAndRequantize' operation.
    pub fn bias(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'min_input' Input of this 'QuantizedConv2DWithBiasAndReluAndRequantize' operation.
    pub fn min_input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'max_input' Input of this 'QuantizedConv2DWithBiasAndReluAndRequantize' operation.
    pub fn max_input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
    /// Returns the 'min_filter' Input of this 'QuantizedConv2DWithBiasAndReluAndRequantize' operation.
    pub fn min_filter(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 5,
        }
    }
    /// Returns the 'max_filter' Input of this 'QuantizedConv2DWithBiasAndReluAndRequantize' operation.
    pub fn max_filter(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 6,
        }
    }
    /// Returns the 'min_freezed_output' Input of this 'QuantizedConv2DWithBiasAndReluAndRequantize' operation.
    pub fn min_freezed_output(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 7,
        }
    }
    /// Returns the 'max_freezed_output' Input of this 'QuantizedConv2DWithBiasAndReluAndRequantize' operation.
    pub fn max_freezed_output(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 8,
        }
    }
}
impl From<QuantizedConv2DWithBiasAndReluAndRequantizeInst> for crate::Operation {
    fn from(inst: QuantizedConv2DWithBiasAndReluAndRequantizeInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `QuantizedConv2DWithBiasAndReluAndRequantize::new().build(input, filter, bias, min_input, max_input, min_filter, max_filter, min_freezed_output, max_freezed_output, scope)`.
pub fn quantized_conv2_dwith_bias_and_relu_and_requantize<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
    O6: ::std::convert::Into<crate::Output>,
    O7: ::std::convert::Into<crate::Output>,
    O8: ::std::convert::Into<crate::Output>,
>(
    input: O0,
    filter: O1,
    bias: O2,
    min_input: O3,
    max_input: O4,
    min_filter: O5,
    max_filter: O6,
    min_freezed_output: O7,
    max_freezed_output: O8,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    QuantizedConv2DWithBiasAndReluAndRequantize::new().build(
        input,
        filter,
        bias,
        min_input,
        max_input,
        min_filter,
        max_filter,
        min_freezed_output,
        max_freezed_output,
        scope,
    )
}

/// Builder for the `QuantizedConv2DWithBiasAndRequantize` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct QuantizedConv2DWithBiasAndRequantize {
    Tinput: ::std::option::Option<crate::DataType>,
    Tfilter: ::std::option::Option<crate::DataType>,
    Tbias: ::std::option::Option<crate::DataType>,
    out_type: ::std::option::Option<crate::DataType>,
    strides: ::std::option::Option<::std::vec::Vec<i64>>,
    padding: ::std::option::Option<::std::string::String>,
    dilations: ::std::option::Option<::std::vec::Vec<i64>>,
    padding_list: ::std::option::Option<::std::vec::Vec<i64>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'QuantizedConv2DWithBiasAndRequantize' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct QuantizedConv2DWithBiasAndRequantizeInst {
    /// An instance of a fully built QuantizedConv2DWithBiasAndRequantize Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl QuantizedConv2DWithBiasAndRequantize {
    /// Creates a new `QuantizedConv2DWithBiasAndRequantize`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `Tinput` attribute.
    pub fn Tinput<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tinput = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tfilter` attribute.
    pub fn Tfilter<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tfilter = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tbias` attribute.
    pub fn Tbias<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Tbias = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `out_type` attribute.
    pub fn out_type<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.out_type = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `strides` attribute.
    pub fn strides<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.strides = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `padding` attribute.
    pub fn padding<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.padding = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `dilations` attribute.
    pub fn dilations<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.dilations = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `padding_list` attribute.
    pub fn padding_list<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.padding_list = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `QuantizedConv2DWithBiasAndRequantize` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
        O6: ::std::convert::Into<crate::Output>,
        O7: ::std::convert::Into<crate::Output>,
        O8: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        filter: O1,
        bias: O2,
        min_input: O3,
        max_input: O4,
        min_filter: O5,
        max_filter: O6,
        min_freezed_output: O7,
        max_freezed_output: O8,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            input.into(),
            filter.into(),
            bias.into(),
            min_input.into(),
            max_input.into(),
            min_filter.into(),
            max_filter.into(),
            min_freezed_output.into(),
            max_freezed_output.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        input: crate::Output,
        filter: crate::Output,
        bias: crate::Output,
        min_input: crate::Output,
        max_input: crate::Output,
        min_filter: crate::Output,
        max_filter: crate::Output,
        min_freezed_output: crate::Output,
        max_freezed_output: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("QuantizedConv2DWithBiasAndRequantize", |nd| {
            nd.add_input(input);
            nd.add_input(filter);
            nd.add_input(bias);
            nd.add_input(min_input);
            nd.add_input(max_input);
            nd.add_input(min_filter);
            nd.add_input(max_filter);
            nd.add_input(min_freezed_output);
            nd.add_input(max_freezed_output);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.Tinput {
                nd.set_attr_type("Tinput", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tfilter {
                nd.set_attr_type("Tfilter", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tbias {
                nd.set_attr_type("Tbias", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.out_type {
                nd.set_attr_type("out_type", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.strides {
                nd.set_attr_int_list("strides", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding {
                nd.set_attr_string("padding", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dilations {
                nd.set_attr_int_list("dilations", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding_list {
                nd.set_attr_int_list("padding_list", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'QuantizedConv2DWithBiasAndRequantize' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        filter: crate::Output,
        bias: crate::Output,
        min_input: crate::Output,
        max_input: crate::Output,
        min_filter: crate::Output,
        max_filter: crate::Output,
        min_freezed_output: crate::Output,
        max_freezed_output: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<QuantizedConv2DWithBiasAndRequantizeInst> {
        let op = scope.new_operation("QuantizedConv2DWithBiasAndRequantize", |builder| {
            builder.add_input(input);
            builder.add_input(filter);
            builder.add_input(bias);
            builder.add_input(min_input);
            builder.add_input(max_input);
            builder.add_input(min_filter);
            builder.add_input(max_filter);
            builder.add_input(min_freezed_output);
            builder.add_input(max_freezed_output);
            if let ::std::option::Option::Some(value) = &self.Tinput {
                builder.set_attr_type("Tinput", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tfilter {
                builder.set_attr_type("Tfilter", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tbias {
                builder.set_attr_type("Tbias", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.out_type {
                builder.set_attr_type("out_type", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.strides {
                builder.set_attr_int_list("strides", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding {
                builder.set_attr_string("padding", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dilations {
                builder.set_attr_int_list("dilations", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding_list {
                builder.set_attr_int_list("padding_list", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(QuantizedConv2DWithBiasAndRequantizeInst { op })
    }
}
impl QuantizedConv2DWithBiasAndRequantizeInst {
    /// Returns the 'output' Output of this 'QuantizedConv2DWithBiasAndRequantize' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'min_output' Output of this 'QuantizedConv2DWithBiasAndRequantize' operation.
    pub fn min_output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'max_output' Output of this 'QuantizedConv2DWithBiasAndRequantize' operation.
    pub fn max_output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns the 'input' Input of this 'QuantizedConv2DWithBiasAndRequantize' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'filter' Input of this 'QuantizedConv2DWithBiasAndRequantize' operation.
    pub fn filter(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'bias' Input of this 'QuantizedConv2DWithBiasAndRequantize' operation.
    pub fn bias(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'min_input' Input of this 'QuantizedConv2DWithBiasAndRequantize' operation.
    pub fn min_input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'max_input' Input of this 'QuantizedConv2DWithBiasAndRequantize' operation.
    pub fn max_input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
    /// Returns the 'min_filter' Input of this 'QuantizedConv2DWithBiasAndRequantize' operation.
    pub fn min_filter(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 5,
        }
    }
    /// Returns the 'max_filter' Input of this 'QuantizedConv2DWithBiasAndRequantize' operation.
    pub fn max_filter(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 6,
        }
    }
    /// Returns the 'min_freezed_output' Input of this 'QuantizedConv2DWithBiasAndRequantize' operation.
    pub fn min_freezed_output(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 7,
        }
    }
    /// Returns the 'max_freezed_output' Input of this 'QuantizedConv2DWithBiasAndRequantize' operation.
    pub fn max_freezed_output(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 8,
        }
    }
}
impl From<QuantizedConv2DWithBiasAndRequantizeInst> for crate::Operation {
    fn from(inst: QuantizedConv2DWithBiasAndRequantizeInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `QuantizedConv2DWithBiasAndRequantize::new().build(input, filter, bias, min_input, max_input, min_filter, max_filter, min_freezed_output, max_freezed_output, scope)`.
pub fn quantized_conv2_dwith_bias_and_requantize<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
    O6: ::std::convert::Into<crate::Output>,
    O7: ::std::convert::Into<crate::Output>,
    O8: ::std::convert::Into<crate::Output>,
>(
    input: O0,
    filter: O1,
    bias: O2,
    min_input: O3,
    max_input: O4,
    min_filter: O5,
    max_filter: O6,
    min_freezed_output: O7,
    max_freezed_output: O8,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    QuantizedConv2DWithBiasAndRequantize::new().build(
        input,
        filter,
        bias,
        min_input,
        max_input,
        min_filter,
        max_filter,
        min_freezed_output,
        max_freezed_output,
        scope,
    )
}

/// Builder for the `QuantizedConv2DWithBiasSignedSumAndReluAndRequantize` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct QuantizedConv2DWithBiasSignedSumAndReluAndRequantize {
    Tinput: ::std::option::Option<crate::DataType>,
    Tfilter: ::std::option::Option<crate::DataType>,
    Tbias: ::std::option::Option<crate::DataType>,
    Tsummand: ::std::option::Option<crate::DataType>,
    out_type: ::std::option::Option<crate::DataType>,
    strides: ::std::option::Option<::std::vec::Vec<i64>>,
    padding: ::std::option::Option<::std::string::String>,
    dilations: ::std::option::Option<::std::vec::Vec<i64>>,
    padding_list: ::std::option::Option<::std::vec::Vec<i64>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'QuantizedConv2DWithBiasSignedSumAndReluAndRequantize' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct QuantizedConv2DWithBiasSignedSumAndReluAndRequantizeInst {
    /// An instance of a fully built QuantizedConv2DWithBiasSignedSumAndReluAndRequantize Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl QuantizedConv2DWithBiasSignedSumAndReluAndRequantize {
    /// Creates a new `QuantizedConv2DWithBiasSignedSumAndReluAndRequantize`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `Tinput` attribute.
    pub fn Tinput<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tinput = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tfilter` attribute.
    pub fn Tfilter<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tfilter = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tbias` attribute.
    pub fn Tbias<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Tbias = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tsummand` attribute.
    pub fn Tsummand<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tsummand = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `out_type` attribute.
    pub fn out_type<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.out_type = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `strides` attribute.
    pub fn strides<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.strides = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `padding` attribute.
    pub fn padding<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.padding = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `dilations` attribute.
    pub fn dilations<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.dilations = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `padding_list` attribute.
    pub fn padding_list<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.padding_list = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `QuantizedConv2DWithBiasSignedSumAndReluAndRequantize` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
        O6: ::std::convert::Into<crate::Output>,
        O7: ::std::convert::Into<crate::Output>,
        O8: ::std::convert::Into<crate::Output>,
        O9: ::std::convert::Into<crate::Output>,
        O10: ::std::convert::Into<crate::Output>,
        O11: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        filter: O1,
        bias: O2,
        min_input: O3,
        max_input: O4,
        min_filter: O5,
        max_filter: O6,
        min_freezed_output: O7,
        max_freezed_output: O8,
        summand: O9,
        min_summand: O10,
        max_summand: O11,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            input.into(),
            filter.into(),
            bias.into(),
            min_input.into(),
            max_input.into(),
            min_filter.into(),
            max_filter.into(),
            min_freezed_output.into(),
            max_freezed_output.into(),
            summand.into(),
            min_summand.into(),
            max_summand.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        input: crate::Output,
        filter: crate::Output,
        bias: crate::Output,
        min_input: crate::Output,
        max_input: crate::Output,
        min_filter: crate::Output,
        max_filter: crate::Output,
        min_freezed_output: crate::Output,
        max_freezed_output: crate::Output,
        summand: crate::Output,
        min_summand: crate::Output,
        max_summand: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation(
            "QuantizedConv2DWithBiasSignedSumAndReluAndRequantize",
            |nd| {
                nd.add_input(input);
                nd.add_input(filter);
                nd.add_input(bias);
                nd.add_input(min_input);
                nd.add_input(max_input);
                nd.add_input(min_filter);
                nd.add_input(max_filter);
                nd.add_input(min_freezed_output);
                nd.add_input(max_freezed_output);
                nd.add_input(summand);
                nd.add_input(min_summand);
                nd.add_input(max_summand);
                for op in &self.control_inputs {
                    nd.add_control_input(op);
                }
                if let ::std::option::Option::Some(value) = &self.Tinput {
                    nd.set_attr_type("Tinput", *value)?;
                }
                if let ::std::option::Option::Some(value) = &self.Tfilter {
                    nd.set_attr_type("Tfilter", *value)?;
                }
                if let ::std::option::Option::Some(value) = &self.Tbias {
                    nd.set_attr_type("Tbias", *value)?;
                }
                if let ::std::option::Option::Some(value) = &self.Tsummand {
                    nd.set_attr_type("Tsummand", *value)?;
                }
                if let ::std::option::Option::Some(value) = &self.out_type {
                    nd.set_attr_type("out_type", *value)?;
                }
                if let ::std::option::Option::Some(value) = &self.strides {
                    nd.set_attr_int_list("strides", value)?;
                }
                if let ::std::option::Option::Some(value) = &self.padding {
                    nd.set_attr_string("padding", value)?;
                }
                if let ::std::option::Option::Some(value) = &self.dilations {
                    nd.set_attr_int_list("dilations", value)?;
                }
                if let ::std::option::Option::Some(value) = &self.padding_list {
                    nd.set_attr_int_list("padding_list", value)?;
                }
                ::std::result::Result::Ok(())
            },
        )
    }

    /// Builds a new instance of 'QuantizedConv2DWithBiasSignedSumAndReluAndRequantize' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        filter: crate::Output,
        bias: crate::Output,
        min_input: crate::Output,
        max_input: crate::Output,
        min_filter: crate::Output,
        max_filter: crate::Output,
        min_freezed_output: crate::Output,
        max_freezed_output: crate::Output,
        summand: crate::Output,
        min_summand: crate::Output,
        max_summand: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<QuantizedConv2DWithBiasSignedSumAndReluAndRequantizeInst> {
        let op = scope.new_operation(
            "QuantizedConv2DWithBiasSignedSumAndReluAndRequantize",
            |builder| {
                builder.add_input(input);
                builder.add_input(filter);
                builder.add_input(bias);
                builder.add_input(min_input);
                builder.add_input(max_input);
                builder.add_input(min_filter);
                builder.add_input(max_filter);
                builder.add_input(min_freezed_output);
                builder.add_input(max_freezed_output);
                builder.add_input(summand);
                builder.add_input(min_summand);
                builder.add_input(max_summand);
                if let ::std::option::Option::Some(value) = &self.Tinput {
                    builder.set_attr_type("Tinput", *value)?;
                }
                if let ::std::option::Option::Some(value) = &self.Tfilter {
                    builder.set_attr_type("Tfilter", *value)?;
                }
                if let ::std::option::Option::Some(value) = &self.Tbias {
                    builder.set_attr_type("Tbias", *value)?;
                }
                if let ::std::option::Option::Some(value) = &self.Tsummand {
                    builder.set_attr_type("Tsummand", *value)?;
                }
                if let ::std::option::Option::Some(value) = &self.out_type {
                    builder.set_attr_type("out_type", *value)?;
                }
                if let ::std::option::Option::Some(value) = &self.strides {
                    builder.set_attr_int_list("strides", value)?;
                }
                if let ::std::option::Option::Some(value) = &self.padding {
                    builder.set_attr_string("padding", value)?;
                }
                if let ::std::option::Option::Some(value) = &self.dilations {
                    builder.set_attr_int_list("dilations", value)?;
                }
                if let ::std::option::Option::Some(value) = &self.padding_list {
                    builder.set_attr_int_list("padding_list", value)?;
                }
                ::std::result::Result::Ok(())
            },
        )?;
        Ok(QuantizedConv2DWithBiasSignedSumAndReluAndRequantizeInst { op })
    }
}
impl QuantizedConv2DWithBiasSignedSumAndReluAndRequantizeInst {
    /// Returns the 'output' Output of this 'QuantizedConv2DWithBiasSignedSumAndReluAndRequantize' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'min_output' Output of this 'QuantizedConv2DWithBiasSignedSumAndReluAndRequantize' operation.
    pub fn min_output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'max_output' Output of this 'QuantizedConv2DWithBiasSignedSumAndReluAndRequantize' operation.
    pub fn max_output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns the 'input' Input of this 'QuantizedConv2DWithBiasSignedSumAndReluAndRequantize' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'filter' Input of this 'QuantizedConv2DWithBiasSignedSumAndReluAndRequantize' operation.
    pub fn filter(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'bias' Input of this 'QuantizedConv2DWithBiasSignedSumAndReluAndRequantize' operation.
    pub fn bias(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'min_input' Input of this 'QuantizedConv2DWithBiasSignedSumAndReluAndRequantize' operation.
    pub fn min_input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'max_input' Input of this 'QuantizedConv2DWithBiasSignedSumAndReluAndRequantize' operation.
    pub fn max_input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
    /// Returns the 'min_filter' Input of this 'QuantizedConv2DWithBiasSignedSumAndReluAndRequantize' operation.
    pub fn min_filter(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 5,
        }
    }
    /// Returns the 'max_filter' Input of this 'QuantizedConv2DWithBiasSignedSumAndReluAndRequantize' operation.
    pub fn max_filter(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 6,
        }
    }
    /// Returns the 'min_freezed_output' Input of this 'QuantizedConv2DWithBiasSignedSumAndReluAndRequantize' operation.
    pub fn min_freezed_output(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 7,
        }
    }
    /// Returns the 'max_freezed_output' Input of this 'QuantizedConv2DWithBiasSignedSumAndReluAndRequantize' operation.
    pub fn max_freezed_output(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 8,
        }
    }
    /// Returns the 'summand' Input of this 'QuantizedConv2DWithBiasSignedSumAndReluAndRequantize' operation.
    pub fn summand(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 9,
        }
    }
    /// Returns the 'min_summand' Input of this 'QuantizedConv2DWithBiasSignedSumAndReluAndRequantize' operation.
    pub fn min_summand(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 10,
        }
    }
    /// Returns the 'max_summand' Input of this 'QuantizedConv2DWithBiasSignedSumAndReluAndRequantize' operation.
    pub fn max_summand(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 11,
        }
    }
}
impl From<QuantizedConv2DWithBiasSignedSumAndReluAndRequantizeInst> for crate::Operation {
    fn from(inst: QuantizedConv2DWithBiasSignedSumAndReluAndRequantizeInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `QuantizedConv2DWithBiasSignedSumAndReluAndRequantize::new().build(input, filter, bias, min_input, max_input, min_filter, max_filter, min_freezed_output, max_freezed_output, summand, min_summand, max_summand, scope)`.
pub fn quantized_conv2_dwith_bias_signed_sum_and_relu_and_requantize<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
    O6: ::std::convert::Into<crate::Output>,
    O7: ::std::convert::Into<crate::Output>,
    O8: ::std::convert::Into<crate::Output>,
    O9: ::std::convert::Into<crate::Output>,
    O10: ::std::convert::Into<crate::Output>,
    O11: ::std::convert::Into<crate::Output>,
>(
    input: O0,
    filter: O1,
    bias: O2,
    min_input: O3,
    max_input: O4,
    min_filter: O5,
    max_filter: O6,
    min_freezed_output: O7,
    max_freezed_output: O8,
    summand: O9,
    min_summand: O10,
    max_summand: O11,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    QuantizedConv2DWithBiasSignedSumAndReluAndRequantize::new().build(
        input,
        filter,
        bias,
        min_input,
        max_input,
        min_filter,
        max_filter,
        min_freezed_output,
        max_freezed_output,
        summand,
        min_summand,
        max_summand,
        scope,
    )
}

/// Builder for the `QuantizedConv2DWithBiasSumAndRelu` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct QuantizedConv2DWithBiasSumAndRelu {
    Tinput: ::std::option::Option<crate::DataType>,
    Tfilter: ::std::option::Option<crate::DataType>,
    out_type: ::std::option::Option<crate::DataType>,
    strides: ::std::option::Option<::std::vec::Vec<i64>>,
    padding: ::std::option::Option<::std::string::String>,
    dilations: ::std::option::Option<::std::vec::Vec<i64>>,
    padding_list: ::std::option::Option<::std::vec::Vec<i64>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'QuantizedConv2DWithBiasSumAndRelu' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct QuantizedConv2DWithBiasSumAndReluInst {
    /// An instance of a fully built QuantizedConv2DWithBiasSumAndRelu Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl QuantizedConv2DWithBiasSumAndRelu {
    /// Creates a new `QuantizedConv2DWithBiasSumAndRelu`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `Tinput` attribute.
    pub fn Tinput<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tinput = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tfilter` attribute.
    pub fn Tfilter<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tfilter = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `out_type` attribute.
    pub fn out_type<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.out_type = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `strides` attribute.
    pub fn strides<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.strides = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `padding` attribute.
    pub fn padding<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.padding = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `dilations` attribute.
    pub fn dilations<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.dilations = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `padding_list` attribute.
    pub fn padding_list<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.padding_list = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `QuantizedConv2DWithBiasSumAndRelu` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
        O6: ::std::convert::Into<crate::Output>,
        O7: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        filter: O1,
        bias: O2,
        min_input: O3,
        max_input: O4,
        min_filter: O5,
        max_filter: O6,
        summand: O7,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            input.into(),
            filter.into(),
            bias.into(),
            min_input.into(),
            max_input.into(),
            min_filter.into(),
            max_filter.into(),
            summand.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        input: crate::Output,
        filter: crate::Output,
        bias: crate::Output,
        min_input: crate::Output,
        max_input: crate::Output,
        min_filter: crate::Output,
        max_filter: crate::Output,
        summand: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("QuantizedConv2DWithBiasSumAndRelu", |nd| {
            nd.add_input(input);
            nd.add_input(filter);
            nd.add_input(bias);
            nd.add_input(min_input);
            nd.add_input(max_input);
            nd.add_input(min_filter);
            nd.add_input(max_filter);
            nd.add_input(summand);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.Tinput {
                nd.set_attr_type("Tinput", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tfilter {
                nd.set_attr_type("Tfilter", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.out_type {
                nd.set_attr_type("out_type", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.strides {
                nd.set_attr_int_list("strides", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding {
                nd.set_attr_string("padding", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dilations {
                nd.set_attr_int_list("dilations", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding_list {
                nd.set_attr_int_list("padding_list", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'QuantizedConv2DWithBiasSumAndRelu' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        filter: crate::Output,
        bias: crate::Output,
        min_input: crate::Output,
        max_input: crate::Output,
        min_filter: crate::Output,
        max_filter: crate::Output,
        summand: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<QuantizedConv2DWithBiasSumAndReluInst> {
        let op = scope.new_operation("QuantizedConv2DWithBiasSumAndRelu", |builder| {
            builder.add_input(input);
            builder.add_input(filter);
            builder.add_input(bias);
            builder.add_input(min_input);
            builder.add_input(max_input);
            builder.add_input(min_filter);
            builder.add_input(max_filter);
            builder.add_input(summand);
            if let ::std::option::Option::Some(value) = &self.Tinput {
                builder.set_attr_type("Tinput", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tfilter {
                builder.set_attr_type("Tfilter", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.out_type {
                builder.set_attr_type("out_type", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.strides {
                builder.set_attr_int_list("strides", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding {
                builder.set_attr_string("padding", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dilations {
                builder.set_attr_int_list("dilations", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding_list {
                builder.set_attr_int_list("padding_list", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(QuantizedConv2DWithBiasSumAndReluInst { op })
    }
}
impl QuantizedConv2DWithBiasSumAndReluInst {
    /// Returns the 'output' Output of this 'QuantizedConv2DWithBiasSumAndRelu' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'min_output' Output of this 'QuantizedConv2DWithBiasSumAndRelu' operation.
    pub fn min_output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'max_output' Output of this 'QuantizedConv2DWithBiasSumAndRelu' operation.
    pub fn max_output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns the 'input' Input of this 'QuantizedConv2DWithBiasSumAndRelu' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'filter' Input of this 'QuantizedConv2DWithBiasSumAndRelu' operation.
    pub fn filter(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'bias' Input of this 'QuantizedConv2DWithBiasSumAndRelu' operation.
    pub fn bias(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'min_input' Input of this 'QuantizedConv2DWithBiasSumAndRelu' operation.
    pub fn min_input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'max_input' Input of this 'QuantizedConv2DWithBiasSumAndRelu' operation.
    pub fn max_input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
    /// Returns the 'min_filter' Input of this 'QuantizedConv2DWithBiasSumAndRelu' operation.
    pub fn min_filter(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 5,
        }
    }
    /// Returns the 'max_filter' Input of this 'QuantizedConv2DWithBiasSumAndRelu' operation.
    pub fn max_filter(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 6,
        }
    }
    /// Returns the 'summand' Input of this 'QuantizedConv2DWithBiasSumAndRelu' operation.
    pub fn summand(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 7,
        }
    }
}
impl From<QuantizedConv2DWithBiasSumAndReluInst> for crate::Operation {
    fn from(inst: QuantizedConv2DWithBiasSumAndReluInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `QuantizedConv2DWithBiasSumAndRelu::new().build(input, filter, bias, min_input, max_input, min_filter, max_filter, summand, scope)`.
pub fn quantized_conv2_dwith_bias_sum_and_relu<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
    O6: ::std::convert::Into<crate::Output>,
    O7: ::std::convert::Into<crate::Output>,
>(
    input: O0,
    filter: O1,
    bias: O2,
    min_input: O3,
    max_input: O4,
    min_filter: O5,
    max_filter: O6,
    summand: O7,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    QuantizedConv2DWithBiasSumAndRelu::new().build(
        input, filter, bias, min_input, max_input, min_filter, max_filter, summand, scope,
    )
}

/// Builder for the `QuantizedConv2DWithBiasSumAndReluAndRequantize` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct QuantizedConv2DWithBiasSumAndReluAndRequantize {
    Tinput: ::std::option::Option<crate::DataType>,
    Tfilter: ::std::option::Option<crate::DataType>,
    Tbias: ::std::option::Option<crate::DataType>,
    Tsummand: ::std::option::Option<crate::DataType>,
    out_type: ::std::option::Option<crate::DataType>,
    strides: ::std::option::Option<::std::vec::Vec<i64>>,
    padding: ::std::option::Option<::std::string::String>,
    dilations: ::std::option::Option<::std::vec::Vec<i64>>,
    padding_list: ::std::option::Option<::std::vec::Vec<i64>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'QuantizedConv2DWithBiasSumAndReluAndRequantize' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct QuantizedConv2DWithBiasSumAndReluAndRequantizeInst {
    /// An instance of a fully built QuantizedConv2DWithBiasSumAndReluAndRequantize Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl QuantizedConv2DWithBiasSumAndReluAndRequantize {
    /// Creates a new `QuantizedConv2DWithBiasSumAndReluAndRequantize`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `Tinput` attribute.
    pub fn Tinput<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tinput = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tfilter` attribute.
    pub fn Tfilter<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tfilter = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tbias` attribute.
    pub fn Tbias<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Tbias = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tsummand` attribute.
    pub fn Tsummand<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tsummand = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `out_type` attribute.
    pub fn out_type<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.out_type = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `strides` attribute.
    pub fn strides<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.strides = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `padding` attribute.
    pub fn padding<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.padding = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `dilations` attribute.
    pub fn dilations<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.dilations = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `padding_list` attribute.
    pub fn padding_list<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.padding_list = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `QuantizedConv2DWithBiasSumAndReluAndRequantize` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
        O6: ::std::convert::Into<crate::Output>,
        O7: ::std::convert::Into<crate::Output>,
        O8: ::std::convert::Into<crate::Output>,
        O9: ::std::convert::Into<crate::Output>,
        O10: ::std::convert::Into<crate::Output>,
        O11: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        filter: O1,
        bias: O2,
        min_input: O3,
        max_input: O4,
        min_filter: O5,
        max_filter: O6,
        min_freezed_output: O7,
        max_freezed_output: O8,
        summand: O9,
        min_summand: O10,
        max_summand: O11,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            input.into(),
            filter.into(),
            bias.into(),
            min_input.into(),
            max_input.into(),
            min_filter.into(),
            max_filter.into(),
            min_freezed_output.into(),
            max_freezed_output.into(),
            summand.into(),
            min_summand.into(),
            max_summand.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        input: crate::Output,
        filter: crate::Output,
        bias: crate::Output,
        min_input: crate::Output,
        max_input: crate::Output,
        min_filter: crate::Output,
        max_filter: crate::Output,
        min_freezed_output: crate::Output,
        max_freezed_output: crate::Output,
        summand: crate::Output,
        min_summand: crate::Output,
        max_summand: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("QuantizedConv2DWithBiasSumAndReluAndRequantize", |nd| {
            nd.add_input(input);
            nd.add_input(filter);
            nd.add_input(bias);
            nd.add_input(min_input);
            nd.add_input(max_input);
            nd.add_input(min_filter);
            nd.add_input(max_filter);
            nd.add_input(min_freezed_output);
            nd.add_input(max_freezed_output);
            nd.add_input(summand);
            nd.add_input(min_summand);
            nd.add_input(max_summand);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.Tinput {
                nd.set_attr_type("Tinput", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tfilter {
                nd.set_attr_type("Tfilter", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tbias {
                nd.set_attr_type("Tbias", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tsummand {
                nd.set_attr_type("Tsummand", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.out_type {
                nd.set_attr_type("out_type", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.strides {
                nd.set_attr_int_list("strides", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding {
                nd.set_attr_string("padding", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dilations {
                nd.set_attr_int_list("dilations", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding_list {
                nd.set_attr_int_list("padding_list", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'QuantizedConv2DWithBiasSumAndReluAndRequantize' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        filter: crate::Output,
        bias: crate::Output,
        min_input: crate::Output,
        max_input: crate::Output,
        min_filter: crate::Output,
        max_filter: crate::Output,
        min_freezed_output: crate::Output,
        max_freezed_output: crate::Output,
        summand: crate::Output,
        min_summand: crate::Output,
        max_summand: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<QuantizedConv2DWithBiasSumAndReluAndRequantizeInst> {
        let op = scope.new_operation(
            "QuantizedConv2DWithBiasSumAndReluAndRequantize",
            |builder| {
                builder.add_input(input);
                builder.add_input(filter);
                builder.add_input(bias);
                builder.add_input(min_input);
                builder.add_input(max_input);
                builder.add_input(min_filter);
                builder.add_input(max_filter);
                builder.add_input(min_freezed_output);
                builder.add_input(max_freezed_output);
                builder.add_input(summand);
                builder.add_input(min_summand);
                builder.add_input(max_summand);
                if let ::std::option::Option::Some(value) = &self.Tinput {
                    builder.set_attr_type("Tinput", *value)?;
                }
                if let ::std::option::Option::Some(value) = &self.Tfilter {
                    builder.set_attr_type("Tfilter", *value)?;
                }
                if let ::std::option::Option::Some(value) = &self.Tbias {
                    builder.set_attr_type("Tbias", *value)?;
                }
                if let ::std::option::Option::Some(value) = &self.Tsummand {
                    builder.set_attr_type("Tsummand", *value)?;
                }
                if let ::std::option::Option::Some(value) = &self.out_type {
                    builder.set_attr_type("out_type", *value)?;
                }
                if let ::std::option::Option::Some(value) = &self.strides {
                    builder.set_attr_int_list("strides", value)?;
                }
                if let ::std::option::Option::Some(value) = &self.padding {
                    builder.set_attr_string("padding", value)?;
                }
                if let ::std::option::Option::Some(value) = &self.dilations {
                    builder.set_attr_int_list("dilations", value)?;
                }
                if let ::std::option::Option::Some(value) = &self.padding_list {
                    builder.set_attr_int_list("padding_list", value)?;
                }
                ::std::result::Result::Ok(())
            },
        )?;
        Ok(QuantizedConv2DWithBiasSumAndReluAndRequantizeInst { op })
    }
}
impl QuantizedConv2DWithBiasSumAndReluAndRequantizeInst {
    /// Returns the 'output' Output of this 'QuantizedConv2DWithBiasSumAndReluAndRequantize' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'min_output' Output of this 'QuantizedConv2DWithBiasSumAndReluAndRequantize' operation.
    pub fn min_output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'max_output' Output of this 'QuantizedConv2DWithBiasSumAndReluAndRequantize' operation.
    pub fn max_output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns the 'input' Input of this 'QuantizedConv2DWithBiasSumAndReluAndRequantize' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'filter' Input of this 'QuantizedConv2DWithBiasSumAndReluAndRequantize' operation.
    pub fn filter(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'bias' Input of this 'QuantizedConv2DWithBiasSumAndReluAndRequantize' operation.
    pub fn bias(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'min_input' Input of this 'QuantizedConv2DWithBiasSumAndReluAndRequantize' operation.
    pub fn min_input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'max_input' Input of this 'QuantizedConv2DWithBiasSumAndReluAndRequantize' operation.
    pub fn max_input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
    /// Returns the 'min_filter' Input of this 'QuantizedConv2DWithBiasSumAndReluAndRequantize' operation.
    pub fn min_filter(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 5,
        }
    }
    /// Returns the 'max_filter' Input of this 'QuantizedConv2DWithBiasSumAndReluAndRequantize' operation.
    pub fn max_filter(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 6,
        }
    }
    /// Returns the 'min_freezed_output' Input of this 'QuantizedConv2DWithBiasSumAndReluAndRequantize' operation.
    pub fn min_freezed_output(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 7,
        }
    }
    /// Returns the 'max_freezed_output' Input of this 'QuantizedConv2DWithBiasSumAndReluAndRequantize' operation.
    pub fn max_freezed_output(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 8,
        }
    }
    /// Returns the 'summand' Input of this 'QuantizedConv2DWithBiasSumAndReluAndRequantize' operation.
    pub fn summand(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 9,
        }
    }
    /// Returns the 'min_summand' Input of this 'QuantizedConv2DWithBiasSumAndReluAndRequantize' operation.
    pub fn min_summand(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 10,
        }
    }
    /// Returns the 'max_summand' Input of this 'QuantizedConv2DWithBiasSumAndReluAndRequantize' operation.
    pub fn max_summand(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 11,
        }
    }
}
impl From<QuantizedConv2DWithBiasSumAndReluAndRequantizeInst> for crate::Operation {
    fn from(inst: QuantizedConv2DWithBiasSumAndReluAndRequantizeInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `QuantizedConv2DWithBiasSumAndReluAndRequantize::new().build(input, filter, bias, min_input, max_input, min_filter, max_filter, min_freezed_output, max_freezed_output, summand, min_summand, max_summand, scope)`.
pub fn quantized_conv2_dwith_bias_sum_and_relu_and_requantize<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
    O6: ::std::convert::Into<crate::Output>,
    O7: ::std::convert::Into<crate::Output>,
    O8: ::std::convert::Into<crate::Output>,
    O9: ::std::convert::Into<crate::Output>,
    O10: ::std::convert::Into<crate::Output>,
    O11: ::std::convert::Into<crate::Output>,
>(
    input: O0,
    filter: O1,
    bias: O2,
    min_input: O3,
    max_input: O4,
    min_filter: O5,
    max_filter: O6,
    min_freezed_output: O7,
    max_freezed_output: O8,
    summand: O9,
    min_summand: O10,
    max_summand: O11,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    QuantizedConv2DWithBiasSumAndReluAndRequantize::new().build(
        input,
        filter,
        bias,
        min_input,
        max_input,
        min_filter,
        max_filter,
        min_freezed_output,
        max_freezed_output,
        summand,
        min_summand,
        max_summand,
        scope,
    )
}

/// Builder for the `QuantizedDepthwiseConv2D` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct QuantizedDepthwiseConv2D {
    Tinput: ::std::option::Option<crate::DataType>,
    Tfilter: ::std::option::Option<crate::DataType>,
    out_type: ::std::option::Option<crate::DataType>,
    strides: ::std::option::Option<::std::vec::Vec<i64>>,
    padding: ::std::option::Option<::std::string::String>,
    dilations: ::std::option::Option<::std::vec::Vec<i64>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'QuantizedDepthwiseConv2D' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct QuantizedDepthwiseConv2DInst {
    /// An instance of a fully built QuantizedDepthwiseConv2D Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl QuantizedDepthwiseConv2D {
    /// Creates a new `QuantizedDepthwiseConv2D`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `Tinput` attribute.
    pub fn Tinput<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tinput = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tfilter` attribute.
    pub fn Tfilter<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tfilter = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `out_type` attribute.
    pub fn out_type<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.out_type = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `strides` attribute.
    pub fn strides<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.strides = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `padding` attribute.
    pub fn padding<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.padding = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `dilations` attribute.
    pub fn dilations<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.dilations = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `QuantizedDepthwiseConv2D` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        filter: O1,
        min_input: O2,
        max_input: O3,
        min_filter: O4,
        max_filter: O5,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            input.into(),
            filter.into(),
            min_input.into(),
            max_input.into(),
            min_filter.into(),
            max_filter.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        input: crate::Output,
        filter: crate::Output,
        min_input: crate::Output,
        max_input: crate::Output,
        min_filter: crate::Output,
        max_filter: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("QuantizedDepthwiseConv2D", |nd| {
            nd.add_input(input);
            nd.add_input(filter);
            nd.add_input(min_input);
            nd.add_input(max_input);
            nd.add_input(min_filter);
            nd.add_input(max_filter);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.Tinput {
                nd.set_attr_type("Tinput", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tfilter {
                nd.set_attr_type("Tfilter", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.out_type {
                nd.set_attr_type("out_type", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.strides {
                nd.set_attr_int_list("strides", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding {
                nd.set_attr_string("padding", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dilations {
                nd.set_attr_int_list("dilations", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'QuantizedDepthwiseConv2D' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        filter: crate::Output,
        min_input: crate::Output,
        max_input: crate::Output,
        min_filter: crate::Output,
        max_filter: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<QuantizedDepthwiseConv2DInst> {
        let op = scope.new_operation("QuantizedDepthwiseConv2D", |builder| {
            builder.add_input(input);
            builder.add_input(filter);
            builder.add_input(min_input);
            builder.add_input(max_input);
            builder.add_input(min_filter);
            builder.add_input(max_filter);
            if let ::std::option::Option::Some(value) = &self.Tinput {
                builder.set_attr_type("Tinput", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tfilter {
                builder.set_attr_type("Tfilter", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.out_type {
                builder.set_attr_type("out_type", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.strides {
                builder.set_attr_int_list("strides", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding {
                builder.set_attr_string("padding", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dilations {
                builder.set_attr_int_list("dilations", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(QuantizedDepthwiseConv2DInst { op })
    }
}
impl QuantizedDepthwiseConv2DInst {
    /// Returns the 'output' Output of this 'QuantizedDepthwiseConv2D' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'min_output' Output of this 'QuantizedDepthwiseConv2D' operation.
    pub fn min_output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'max_output' Output of this 'QuantizedDepthwiseConv2D' operation.
    pub fn max_output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns the 'input' Input of this 'QuantizedDepthwiseConv2D' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'filter' Input of this 'QuantizedDepthwiseConv2D' operation.
    pub fn filter(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'min_input' Input of this 'QuantizedDepthwiseConv2D' operation.
    pub fn min_input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'max_input' Input of this 'QuantizedDepthwiseConv2D' operation.
    pub fn max_input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'min_filter' Input of this 'QuantizedDepthwiseConv2D' operation.
    pub fn min_filter(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
    /// Returns the 'max_filter' Input of this 'QuantizedDepthwiseConv2D' operation.
    pub fn max_filter(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 5,
        }
    }
}
impl From<QuantizedDepthwiseConv2DInst> for crate::Operation {
    fn from(inst: QuantizedDepthwiseConv2DInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `QuantizedDepthwiseConv2D::new().build(input, filter, min_input, max_input, min_filter, max_filter, scope)`.
pub fn quantized_depthwise_conv2_d<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
>(
    input: O0,
    filter: O1,
    min_input: O2,
    max_input: O3,
    min_filter: O4,
    max_filter: O5,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    QuantizedDepthwiseConv2D::new().build(
        input, filter, min_input, max_input, min_filter, max_filter, scope,
    )
}

/// Builder for the `QuantizedDepthwiseConv2DWithBias` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct QuantizedDepthwiseConv2DWithBias {
    Tinput: ::std::option::Option<crate::DataType>,
    Tfilter: ::std::option::Option<crate::DataType>,
    out_type: ::std::option::Option<crate::DataType>,
    strides: ::std::option::Option<::std::vec::Vec<i64>>,
    padding: ::std::option::Option<::std::string::String>,
    dilations: ::std::option::Option<::std::vec::Vec<i64>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'QuantizedDepthwiseConv2DWithBias' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct QuantizedDepthwiseConv2DWithBiasInst {
    /// An instance of a fully built QuantizedDepthwiseConv2DWithBias Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl QuantizedDepthwiseConv2DWithBias {
    /// Creates a new `QuantizedDepthwiseConv2DWithBias`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `Tinput` attribute.
    pub fn Tinput<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tinput = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tfilter` attribute.
    pub fn Tfilter<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tfilter = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `out_type` attribute.
    pub fn out_type<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.out_type = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `strides` attribute.
    pub fn strides<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.strides = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `padding` attribute.
    pub fn padding<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.padding = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `dilations` attribute.
    pub fn dilations<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.dilations = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `QuantizedDepthwiseConv2DWithBias` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
        O6: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        filter: O1,
        bias: O2,
        min_input: O3,
        max_input: O4,
        min_filter: O5,
        max_filter: O6,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            input.into(),
            filter.into(),
            bias.into(),
            min_input.into(),
            max_input.into(),
            min_filter.into(),
            max_filter.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        input: crate::Output,
        filter: crate::Output,
        bias: crate::Output,
        min_input: crate::Output,
        max_input: crate::Output,
        min_filter: crate::Output,
        max_filter: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("QuantizedDepthwiseConv2DWithBias", |nd| {
            nd.add_input(input);
            nd.add_input(filter);
            nd.add_input(bias);
            nd.add_input(min_input);
            nd.add_input(max_input);
            nd.add_input(min_filter);
            nd.add_input(max_filter);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.Tinput {
                nd.set_attr_type("Tinput", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tfilter {
                nd.set_attr_type("Tfilter", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.out_type {
                nd.set_attr_type("out_type", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.strides {
                nd.set_attr_int_list("strides", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding {
                nd.set_attr_string("padding", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dilations {
                nd.set_attr_int_list("dilations", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'QuantizedDepthwiseConv2DWithBias' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        filter: crate::Output,
        bias: crate::Output,
        min_input: crate::Output,
        max_input: crate::Output,
        min_filter: crate::Output,
        max_filter: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<QuantizedDepthwiseConv2DWithBiasInst> {
        let op = scope.new_operation("QuantizedDepthwiseConv2DWithBias", |builder| {
            builder.add_input(input);
            builder.add_input(filter);
            builder.add_input(bias);
            builder.add_input(min_input);
            builder.add_input(max_input);
            builder.add_input(min_filter);
            builder.add_input(max_filter);
            if let ::std::option::Option::Some(value) = &self.Tinput {
                builder.set_attr_type("Tinput", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tfilter {
                builder.set_attr_type("Tfilter", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.out_type {
                builder.set_attr_type("out_type", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.strides {
                builder.set_attr_int_list("strides", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding {
                builder.set_attr_string("padding", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dilations {
                builder.set_attr_int_list("dilations", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(QuantizedDepthwiseConv2DWithBiasInst { op })
    }
}
impl QuantizedDepthwiseConv2DWithBiasInst {
    /// Returns the 'output' Output of this 'QuantizedDepthwiseConv2DWithBias' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'min_output' Output of this 'QuantizedDepthwiseConv2DWithBias' operation.
    pub fn min_output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'max_output' Output of this 'QuantizedDepthwiseConv2DWithBias' operation.
    pub fn max_output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns the 'input' Input of this 'QuantizedDepthwiseConv2DWithBias' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'filter' Input of this 'QuantizedDepthwiseConv2DWithBias' operation.
    pub fn filter(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'bias' Input of this 'QuantizedDepthwiseConv2DWithBias' operation.
    pub fn bias(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'min_input' Input of this 'QuantizedDepthwiseConv2DWithBias' operation.
    pub fn min_input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'max_input' Input of this 'QuantizedDepthwiseConv2DWithBias' operation.
    pub fn max_input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
    /// Returns the 'min_filter' Input of this 'QuantizedDepthwiseConv2DWithBias' operation.
    pub fn min_filter(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 5,
        }
    }
    /// Returns the 'max_filter' Input of this 'QuantizedDepthwiseConv2DWithBias' operation.
    pub fn max_filter(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 6,
        }
    }
}
impl From<QuantizedDepthwiseConv2DWithBiasInst> for crate::Operation {
    fn from(inst: QuantizedDepthwiseConv2DWithBiasInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `QuantizedDepthwiseConv2DWithBias::new().build(input, filter, bias, min_input, max_input, min_filter, max_filter, scope)`.
pub fn quantized_depthwise_conv2_dwith_bias<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
    O6: ::std::convert::Into<crate::Output>,
>(
    input: O0,
    filter: O1,
    bias: O2,
    min_input: O3,
    max_input: O4,
    min_filter: O5,
    max_filter: O6,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    QuantizedDepthwiseConv2DWithBias::new().build(
        input, filter, bias, min_input, max_input, min_filter, max_filter, scope,
    )
}

/// Builder for the `QuantizedDepthwiseConv2DWithBiasAndRelu` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct QuantizedDepthwiseConv2DWithBiasAndRelu {
    Tinput: ::std::option::Option<crate::DataType>,
    Tfilter: ::std::option::Option<crate::DataType>,
    out_type: ::std::option::Option<crate::DataType>,
    strides: ::std::option::Option<::std::vec::Vec<i64>>,
    padding: ::std::option::Option<::std::string::String>,
    dilations: ::std::option::Option<::std::vec::Vec<i64>>,
    padding_list: ::std::option::Option<::std::vec::Vec<i64>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'QuantizedDepthwiseConv2DWithBiasAndRelu' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct QuantizedDepthwiseConv2DWithBiasAndReluInst {
    /// An instance of a fully built QuantizedDepthwiseConv2DWithBiasAndRelu Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl QuantizedDepthwiseConv2DWithBiasAndRelu {
    /// Creates a new `QuantizedDepthwiseConv2DWithBiasAndRelu`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `Tinput` attribute.
    pub fn Tinput<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tinput = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tfilter` attribute.
    pub fn Tfilter<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tfilter = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `out_type` attribute.
    pub fn out_type<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.out_type = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `strides` attribute.
    pub fn strides<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.strides = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `padding` attribute.
    pub fn padding<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.padding = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `dilations` attribute.
    pub fn dilations<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.dilations = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `padding_list` attribute.
    pub fn padding_list<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.padding_list = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `QuantizedDepthwiseConv2DWithBiasAndRelu` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
        O6: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        filter: O1,
        bias: O2,
        min_input: O3,
        max_input: O4,
        min_filter: O5,
        max_filter: O6,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            input.into(),
            filter.into(),
            bias.into(),
            min_input.into(),
            max_input.into(),
            min_filter.into(),
            max_filter.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        input: crate::Output,
        filter: crate::Output,
        bias: crate::Output,
        min_input: crate::Output,
        max_input: crate::Output,
        min_filter: crate::Output,
        max_filter: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("QuantizedDepthwiseConv2DWithBiasAndRelu", |nd| {
            nd.add_input(input);
            nd.add_input(filter);
            nd.add_input(bias);
            nd.add_input(min_input);
            nd.add_input(max_input);
            nd.add_input(min_filter);
            nd.add_input(max_filter);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.Tinput {
                nd.set_attr_type("Tinput", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tfilter {
                nd.set_attr_type("Tfilter", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.out_type {
                nd.set_attr_type("out_type", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.strides {
                nd.set_attr_int_list("strides", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding {
                nd.set_attr_string("padding", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dilations {
                nd.set_attr_int_list("dilations", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding_list {
                nd.set_attr_int_list("padding_list", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'QuantizedDepthwiseConv2DWithBiasAndRelu' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        filter: crate::Output,
        bias: crate::Output,
        min_input: crate::Output,
        max_input: crate::Output,
        min_filter: crate::Output,
        max_filter: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<QuantizedDepthwiseConv2DWithBiasAndReluInst> {
        let op = scope.new_operation("QuantizedDepthwiseConv2DWithBiasAndRelu", |builder| {
            builder.add_input(input);
            builder.add_input(filter);
            builder.add_input(bias);
            builder.add_input(min_input);
            builder.add_input(max_input);
            builder.add_input(min_filter);
            builder.add_input(max_filter);
            if let ::std::option::Option::Some(value) = &self.Tinput {
                builder.set_attr_type("Tinput", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tfilter {
                builder.set_attr_type("Tfilter", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.out_type {
                builder.set_attr_type("out_type", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.strides {
                builder.set_attr_int_list("strides", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding {
                builder.set_attr_string("padding", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dilations {
                builder.set_attr_int_list("dilations", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding_list {
                builder.set_attr_int_list("padding_list", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(QuantizedDepthwiseConv2DWithBiasAndReluInst { op })
    }
}
impl QuantizedDepthwiseConv2DWithBiasAndReluInst {
    /// Returns the 'output' Output of this 'QuantizedDepthwiseConv2DWithBiasAndRelu' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'min_output' Output of this 'QuantizedDepthwiseConv2DWithBiasAndRelu' operation.
    pub fn min_output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'max_output' Output of this 'QuantizedDepthwiseConv2DWithBiasAndRelu' operation.
    pub fn max_output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns the 'input' Input of this 'QuantizedDepthwiseConv2DWithBiasAndRelu' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'filter' Input of this 'QuantizedDepthwiseConv2DWithBiasAndRelu' operation.
    pub fn filter(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'bias' Input of this 'QuantizedDepthwiseConv2DWithBiasAndRelu' operation.
    pub fn bias(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'min_input' Input of this 'QuantizedDepthwiseConv2DWithBiasAndRelu' operation.
    pub fn min_input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'max_input' Input of this 'QuantizedDepthwiseConv2DWithBiasAndRelu' operation.
    pub fn max_input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
    /// Returns the 'min_filter' Input of this 'QuantizedDepthwiseConv2DWithBiasAndRelu' operation.
    pub fn min_filter(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 5,
        }
    }
    /// Returns the 'max_filter' Input of this 'QuantizedDepthwiseConv2DWithBiasAndRelu' operation.
    pub fn max_filter(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 6,
        }
    }
}
impl From<QuantizedDepthwiseConv2DWithBiasAndReluInst> for crate::Operation {
    fn from(inst: QuantizedDepthwiseConv2DWithBiasAndReluInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `QuantizedDepthwiseConv2DWithBiasAndRelu::new().build(input, filter, bias, min_input, max_input, min_filter, max_filter, scope)`.
pub fn quantized_depthwise_conv2_dwith_bias_and_relu<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
    O6: ::std::convert::Into<crate::Output>,
>(
    input: O0,
    filter: O1,
    bias: O2,
    min_input: O3,
    max_input: O4,
    min_filter: O5,
    max_filter: O6,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    QuantizedDepthwiseConv2DWithBiasAndRelu::new().build(
        input, filter, bias, min_input, max_input, min_filter, max_filter, scope,
    )
}

/// Builder for the `QuantizedDepthwiseConv2DWithBiasAndReluAndRequantize` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct QuantizedDepthwiseConv2DWithBiasAndReluAndRequantize {
    Tinput: ::std::option::Option<crate::DataType>,
    Tfilter: ::std::option::Option<crate::DataType>,
    Tbias: ::std::option::Option<crate::DataType>,
    out_type: ::std::option::Option<crate::DataType>,
    strides: ::std::option::Option<::std::vec::Vec<i64>>,
    padding: ::std::option::Option<::std::string::String>,
    dilations: ::std::option::Option<::std::vec::Vec<i64>>,
    padding_list: ::std::option::Option<::std::vec::Vec<i64>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'QuantizedDepthwiseConv2DWithBiasAndReluAndRequantize' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct QuantizedDepthwiseConv2DWithBiasAndReluAndRequantizeInst {
    /// An instance of a fully built QuantizedDepthwiseConv2DWithBiasAndReluAndRequantize Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl QuantizedDepthwiseConv2DWithBiasAndReluAndRequantize {
    /// Creates a new `QuantizedDepthwiseConv2DWithBiasAndReluAndRequantize`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `Tinput` attribute.
    pub fn Tinput<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tinput = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tfilter` attribute.
    pub fn Tfilter<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tfilter = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tbias` attribute.
    pub fn Tbias<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Tbias = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `out_type` attribute.
    pub fn out_type<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.out_type = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `strides` attribute.
    pub fn strides<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.strides = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `padding` attribute.
    pub fn padding<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.padding = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `dilations` attribute.
    pub fn dilations<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.dilations = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `padding_list` attribute.
    pub fn padding_list<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.padding_list = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `QuantizedDepthwiseConv2DWithBiasAndReluAndRequantize` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
        O6: ::std::convert::Into<crate::Output>,
        O7: ::std::convert::Into<crate::Output>,
        O8: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        filter: O1,
        bias: O2,
        min_input: O3,
        max_input: O4,
        min_filter: O5,
        max_filter: O6,
        min_freezed_output: O7,
        max_freezed_output: O8,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            input.into(),
            filter.into(),
            bias.into(),
            min_input.into(),
            max_input.into(),
            min_filter.into(),
            max_filter.into(),
            min_freezed_output.into(),
            max_freezed_output.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        input: crate::Output,
        filter: crate::Output,
        bias: crate::Output,
        min_input: crate::Output,
        max_input: crate::Output,
        min_filter: crate::Output,
        max_filter: crate::Output,
        min_freezed_output: crate::Output,
        max_freezed_output: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation(
            "QuantizedDepthwiseConv2DWithBiasAndReluAndRequantize",
            |nd| {
                nd.add_input(input);
                nd.add_input(filter);
                nd.add_input(bias);
                nd.add_input(min_input);
                nd.add_input(max_input);
                nd.add_input(min_filter);
                nd.add_input(max_filter);
                nd.add_input(min_freezed_output);
                nd.add_input(max_freezed_output);
                for op in &self.control_inputs {
                    nd.add_control_input(op);
                }
                if let ::std::option::Option::Some(value) = &self.Tinput {
                    nd.set_attr_type("Tinput", *value)?;
                }
                if let ::std::option::Option::Some(value) = &self.Tfilter {
                    nd.set_attr_type("Tfilter", *value)?;
                }
                if let ::std::option::Option::Some(value) = &self.Tbias {
                    nd.set_attr_type("Tbias", *value)?;
                }
                if let ::std::option::Option::Some(value) = &self.out_type {
                    nd.set_attr_type("out_type", *value)?;
                }
                if let ::std::option::Option::Some(value) = &self.strides {
                    nd.set_attr_int_list("strides", value)?;
                }
                if let ::std::option::Option::Some(value) = &self.padding {
                    nd.set_attr_string("padding", value)?;
                }
                if let ::std::option::Option::Some(value) = &self.dilations {
                    nd.set_attr_int_list("dilations", value)?;
                }
                if let ::std::option::Option::Some(value) = &self.padding_list {
                    nd.set_attr_int_list("padding_list", value)?;
                }
                ::std::result::Result::Ok(())
            },
        )
    }

    /// Builds a new instance of 'QuantizedDepthwiseConv2DWithBiasAndReluAndRequantize' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        filter: crate::Output,
        bias: crate::Output,
        min_input: crate::Output,
        max_input: crate::Output,
        min_filter: crate::Output,
        max_filter: crate::Output,
        min_freezed_output: crate::Output,
        max_freezed_output: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<QuantizedDepthwiseConv2DWithBiasAndReluAndRequantizeInst> {
        let op = scope.new_operation(
            "QuantizedDepthwiseConv2DWithBiasAndReluAndRequantize",
            |builder| {
                builder.add_input(input);
                builder.add_input(filter);
                builder.add_input(bias);
                builder.add_input(min_input);
                builder.add_input(max_input);
                builder.add_input(min_filter);
                builder.add_input(max_filter);
                builder.add_input(min_freezed_output);
                builder.add_input(max_freezed_output);
                if let ::std::option::Option::Some(value) = &self.Tinput {
                    builder.set_attr_type("Tinput", *value)?;
                }
                if let ::std::option::Option::Some(value) = &self.Tfilter {
                    builder.set_attr_type("Tfilter", *value)?;
                }
                if let ::std::option::Option::Some(value) = &self.Tbias {
                    builder.set_attr_type("Tbias", *value)?;
                }
                if let ::std::option::Option::Some(value) = &self.out_type {
                    builder.set_attr_type("out_type", *value)?;
                }
                if let ::std::option::Option::Some(value) = &self.strides {
                    builder.set_attr_int_list("strides", value)?;
                }
                if let ::std::option::Option::Some(value) = &self.padding {
                    builder.set_attr_string("padding", value)?;
                }
                if let ::std::option::Option::Some(value) = &self.dilations {
                    builder.set_attr_int_list("dilations", value)?;
                }
                if let ::std::option::Option::Some(value) = &self.padding_list {
                    builder.set_attr_int_list("padding_list", value)?;
                }
                ::std::result::Result::Ok(())
            },
        )?;
        Ok(QuantizedDepthwiseConv2DWithBiasAndReluAndRequantizeInst { op })
    }
}
impl QuantizedDepthwiseConv2DWithBiasAndReluAndRequantizeInst {
    /// Returns the 'output' Output of this 'QuantizedDepthwiseConv2DWithBiasAndReluAndRequantize' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'min_output' Output of this 'QuantizedDepthwiseConv2DWithBiasAndReluAndRequantize' operation.
    pub fn min_output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'max_output' Output of this 'QuantizedDepthwiseConv2DWithBiasAndReluAndRequantize' operation.
    pub fn max_output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns the 'input' Input of this 'QuantizedDepthwiseConv2DWithBiasAndReluAndRequantize' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'filter' Input of this 'QuantizedDepthwiseConv2DWithBiasAndReluAndRequantize' operation.
    pub fn filter(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'bias' Input of this 'QuantizedDepthwiseConv2DWithBiasAndReluAndRequantize' operation.
    pub fn bias(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'min_input' Input of this 'QuantizedDepthwiseConv2DWithBiasAndReluAndRequantize' operation.
    pub fn min_input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'max_input' Input of this 'QuantizedDepthwiseConv2DWithBiasAndReluAndRequantize' operation.
    pub fn max_input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
    /// Returns the 'min_filter' Input of this 'QuantizedDepthwiseConv2DWithBiasAndReluAndRequantize' operation.
    pub fn min_filter(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 5,
        }
    }
    /// Returns the 'max_filter' Input of this 'QuantizedDepthwiseConv2DWithBiasAndReluAndRequantize' operation.
    pub fn max_filter(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 6,
        }
    }
    /// Returns the 'min_freezed_output' Input of this 'QuantizedDepthwiseConv2DWithBiasAndReluAndRequantize' operation.
    pub fn min_freezed_output(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 7,
        }
    }
    /// Returns the 'max_freezed_output' Input of this 'QuantizedDepthwiseConv2DWithBiasAndReluAndRequantize' operation.
    pub fn max_freezed_output(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 8,
        }
    }
}
impl From<QuantizedDepthwiseConv2DWithBiasAndReluAndRequantizeInst> for crate::Operation {
    fn from(inst: QuantizedDepthwiseConv2DWithBiasAndReluAndRequantizeInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `QuantizedDepthwiseConv2DWithBiasAndReluAndRequantize::new().build(input, filter, bias, min_input, max_input, min_filter, max_filter, min_freezed_output, max_freezed_output, scope)`.
pub fn quantized_depthwise_conv2_dwith_bias_and_relu_and_requantize<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
    O6: ::std::convert::Into<crate::Output>,
    O7: ::std::convert::Into<crate::Output>,
    O8: ::std::convert::Into<crate::Output>,
>(
    input: O0,
    filter: O1,
    bias: O2,
    min_input: O3,
    max_input: O4,
    min_filter: O5,
    max_filter: O6,
    min_freezed_output: O7,
    max_freezed_output: O8,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    QuantizedDepthwiseConv2DWithBiasAndReluAndRequantize::new().build(
        input,
        filter,
        bias,
        min_input,
        max_input,
        min_filter,
        max_filter,
        min_freezed_output,
        max_freezed_output,
        scope,
    )
}

/// Builder for the `QuantizedInstanceNorm` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct QuantizedInstanceNorm {
    T: ::std::option::Option<crate::DataType>,
    output_range_given: ::std::option::Option<bool>,
    given_y_min: ::std::option::Option<f32>,
    given_y_max: ::std::option::Option<f32>,
    variance_epsilon: ::std::option::Option<f32>,
    min_separation: ::std::option::Option<f32>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'QuantizedInstanceNorm' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct QuantizedInstanceNormInst {
    /// An instance of a fully built QuantizedInstanceNorm Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl QuantizedInstanceNorm {
    /// Creates a new `QuantizedInstanceNorm`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_range_given` attribute.
    pub fn output_range_given<ArgType: ::std::convert::Into<bool>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_range_given = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `given_y_min` attribute.
    pub fn given_y_min<ArgType: ::std::convert::Into<f32>>(mut self, value: ArgType) -> Self {
        self.given_y_min = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `given_y_max` attribute.
    pub fn given_y_max<ArgType: ::std::convert::Into<f32>>(mut self, value: ArgType) -> Self {
        self.given_y_max = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `variance_epsilon` attribute.
    pub fn variance_epsilon<ArgType: ::std::convert::Into<f32>>(mut self, value: ArgType) -> Self {
        self.variance_epsilon = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `min_separation` attribute.
    pub fn min_separation<ArgType: ::std::convert::Into<f32>>(mut self, value: ArgType) -> Self {
        self.min_separation = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `QuantizedInstanceNorm` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        x: O0,
        x_min: O1,
        x_max: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), x_min.into(), x_max.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        x_min: crate::Output,
        x_max: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("QuantizedInstanceNorm", |nd| {
            nd.add_input(x);
            nd.add_input(x_min);
            nd.add_input(x_max);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_range_given {
                nd.set_attr_bool("output_range_given", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.given_y_min {
                nd.set_attr_float("given_y_min", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.given_y_max {
                nd.set_attr_float("given_y_max", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.variance_epsilon {
                nd.set_attr_float("variance_epsilon", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.min_separation {
                nd.set_attr_float("min_separation", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'QuantizedInstanceNorm' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        x_min: crate::Output,
        x_max: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<QuantizedInstanceNormInst> {
        let op = scope.new_operation("QuantizedInstanceNorm", |builder| {
            builder.add_input(x);
            builder.add_input(x_min);
            builder.add_input(x_max);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_range_given {
                builder.set_attr_bool("output_range_given", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.given_y_min {
                builder.set_attr_float("given_y_min", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.given_y_max {
                builder.set_attr_float("given_y_max", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.variance_epsilon {
                builder.set_attr_float("variance_epsilon", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.min_separation {
                builder.set_attr_float("min_separation", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(QuantizedInstanceNormInst { op })
    }
}
impl QuantizedInstanceNormInst {
    /// Returns the 'y' Output of this 'QuantizedInstanceNorm' operation.
    pub fn y(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'y_min' Output of this 'QuantizedInstanceNorm' operation.
    pub fn y_min(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'y_max' Output of this 'QuantizedInstanceNorm' operation.
    pub fn y_max(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns the 'x' Input of this 'QuantizedInstanceNorm' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'x_min' Input of this 'QuantizedInstanceNorm' operation.
    pub fn x_min(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'x_max' Input of this 'QuantizedInstanceNorm' operation.
    pub fn x_max(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<QuantizedInstanceNormInst> for crate::Operation {
    fn from(inst: QuantizedInstanceNormInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `QuantizedInstanceNorm::new().build(x, x_min, x_max, scope)`.
pub fn quantized_instance_norm<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    x: O0,
    x_min: O1,
    x_max: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    QuantizedInstanceNorm::new().build(x, x_min, x_max, scope)
}

/// Builder for the `QuantizedMatMul` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct QuantizedMatMul {
    T1: ::std::option::Option<crate::DataType>,
    T2: ::std::option::Option<crate::DataType>,
    Toutput: ::std::option::Option<crate::DataType>,
    transpose_a: ::std::option::Option<bool>,
    transpose_b: ::std::option::Option<bool>,
    Tactivation: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'QuantizedMatMul' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct QuantizedMatMulInst {
    /// An instance of a fully built QuantizedMatMul Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl QuantizedMatMul {
    /// Creates a new `QuantizedMatMul`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T1` attribute.
    pub fn T1<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T1 = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T2` attribute.
    pub fn T2<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T2 = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Toutput` attribute.
    pub fn Toutput<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Toutput = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `transpose_a` attribute.
    pub fn transpose_a<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.transpose_a = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `transpose_b` attribute.
    pub fn transpose_b<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.transpose_b = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tactivation` attribute.
    pub fn Tactivation<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tactivation = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `QuantizedMatMul` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
    >(
        &self,
        a: O0,
        b: O1,
        min_a: O2,
        max_a: O3,
        min_b: O4,
        max_b: O5,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            a.into(),
            b.into(),
            min_a.into(),
            max_a.into(),
            min_b.into(),
            max_b.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        a: crate::Output,
        b: crate::Output,
        min_a: crate::Output,
        max_a: crate::Output,
        min_b: crate::Output,
        max_b: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("QuantizedMatMul", |nd| {
            nd.add_input(a);
            nd.add_input(b);
            nd.add_input(min_a);
            nd.add_input(max_a);
            nd.add_input(min_b);
            nd.add_input(max_b);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T1 {
                nd.set_attr_type("T1", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T2 {
                nd.set_attr_type("T2", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Toutput {
                nd.set_attr_type("Toutput", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.transpose_a {
                nd.set_attr_bool("transpose_a", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.transpose_b {
                nd.set_attr_bool("transpose_b", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tactivation {
                nd.set_attr_type("Tactivation", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'QuantizedMatMul' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        a: crate::Output,
        b: crate::Output,
        min_a: crate::Output,
        max_a: crate::Output,
        min_b: crate::Output,
        max_b: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<QuantizedMatMulInst> {
        let op = scope.new_operation("QuantizedMatMul", |builder| {
            builder.add_input(a);
            builder.add_input(b);
            builder.add_input(min_a);
            builder.add_input(max_a);
            builder.add_input(min_b);
            builder.add_input(max_b);
            if let ::std::option::Option::Some(value) = &self.T1 {
                builder.set_attr_type("T1", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T2 {
                builder.set_attr_type("T2", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Toutput {
                builder.set_attr_type("Toutput", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.transpose_a {
                builder.set_attr_bool("transpose_a", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.transpose_b {
                builder.set_attr_bool("transpose_b", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tactivation {
                builder.set_attr_type("Tactivation", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(QuantizedMatMulInst { op })
    }
}
impl QuantizedMatMulInst {
    /// Returns the 'out' Output of this 'QuantizedMatMul' operation.
    pub fn out(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'min_out' Output of this 'QuantizedMatMul' operation.
    pub fn min_out(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'max_out' Output of this 'QuantizedMatMul' operation.
    pub fn max_out(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns the 'a' Input of this 'QuantizedMatMul' operation.
    pub fn a(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'b' Input of this 'QuantizedMatMul' operation.
    pub fn b(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'min_a' Input of this 'QuantizedMatMul' operation.
    pub fn min_a(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'max_a' Input of this 'QuantizedMatMul' operation.
    pub fn max_a(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'min_b' Input of this 'QuantizedMatMul' operation.
    pub fn min_b(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
    /// Returns the 'max_b' Input of this 'QuantizedMatMul' operation.
    pub fn max_b(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 5,
        }
    }
}
impl From<QuantizedMatMulInst> for crate::Operation {
    fn from(inst: QuantizedMatMulInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `QuantizedMatMul::new().build(a, b, min_a, max_a, min_b, max_b, scope)`.
pub fn quantized_mat_mul<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
>(
    a: O0,
    b: O1,
    min_a: O2,
    max_a: O3,
    min_b: O4,
    max_b: O5,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    QuantizedMatMul::new().build(a, b, min_a, max_a, min_b, max_b, scope)
}

/// Builder for the `QuantizedMatMulWithBias` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct QuantizedMatMulWithBias {
    T1: ::std::option::Option<crate::DataType>,
    T2: ::std::option::Option<crate::DataType>,
    Tbias: ::std::option::Option<crate::DataType>,
    Toutput: ::std::option::Option<crate::DataType>,
    transpose_a: ::std::option::Option<bool>,
    transpose_b: ::std::option::Option<bool>,
    input_quant_mode: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'QuantizedMatMulWithBias' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct QuantizedMatMulWithBiasInst {
    /// An instance of a fully built QuantizedMatMulWithBias Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl QuantizedMatMulWithBias {
    /// Creates a new `QuantizedMatMulWithBias`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T1` attribute.
    pub fn T1<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T1 = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T2` attribute.
    pub fn T2<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T2 = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tbias` attribute.
    pub fn Tbias<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Tbias = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Toutput` attribute.
    pub fn Toutput<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Toutput = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `transpose_a` attribute.
    pub fn transpose_a<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.transpose_a = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `transpose_b` attribute.
    pub fn transpose_b<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.transpose_b = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `input_quant_mode` attribute.
    pub fn input_quant_mode<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.input_quant_mode = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `QuantizedMatMulWithBias` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
        O6: ::std::convert::Into<crate::Output>,
    >(
        &self,
        a: O0,
        b: O1,
        bias: O2,
        min_a: O3,
        max_a: O4,
        min_b: O5,
        max_b: O6,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            a.into(),
            b.into(),
            bias.into(),
            min_a.into(),
            max_a.into(),
            min_b.into(),
            max_b.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        a: crate::Output,
        b: crate::Output,
        bias: crate::Output,
        min_a: crate::Output,
        max_a: crate::Output,
        min_b: crate::Output,
        max_b: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("QuantizedMatMulWithBias", |nd| {
            nd.add_input(a);
            nd.add_input(b);
            nd.add_input(bias);
            nd.add_input(min_a);
            nd.add_input(max_a);
            nd.add_input(min_b);
            nd.add_input(max_b);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T1 {
                nd.set_attr_type("T1", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T2 {
                nd.set_attr_type("T2", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tbias {
                nd.set_attr_type("Tbias", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Toutput {
                nd.set_attr_type("Toutput", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.transpose_a {
                nd.set_attr_bool("transpose_a", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.transpose_b {
                nd.set_attr_bool("transpose_b", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.input_quant_mode {
                nd.set_attr_string("input_quant_mode", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'QuantizedMatMulWithBias' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        a: crate::Output,
        b: crate::Output,
        bias: crate::Output,
        min_a: crate::Output,
        max_a: crate::Output,
        min_b: crate::Output,
        max_b: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<QuantizedMatMulWithBiasInst> {
        let op = scope.new_operation("QuantizedMatMulWithBias", |builder| {
            builder.add_input(a);
            builder.add_input(b);
            builder.add_input(bias);
            builder.add_input(min_a);
            builder.add_input(max_a);
            builder.add_input(min_b);
            builder.add_input(max_b);
            if let ::std::option::Option::Some(value) = &self.T1 {
                builder.set_attr_type("T1", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T2 {
                builder.set_attr_type("T2", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tbias {
                builder.set_attr_type("Tbias", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Toutput {
                builder.set_attr_type("Toutput", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.transpose_a {
                builder.set_attr_bool("transpose_a", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.transpose_b {
                builder.set_attr_bool("transpose_b", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.input_quant_mode {
                builder.set_attr_string("input_quant_mode", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(QuantizedMatMulWithBiasInst { op })
    }
}
impl QuantizedMatMulWithBiasInst {
    /// Returns the 'out' Output of this 'QuantizedMatMulWithBias' operation.
    pub fn out(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'min_out' Output of this 'QuantizedMatMulWithBias' operation.
    pub fn min_out(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'max_out' Output of this 'QuantizedMatMulWithBias' operation.
    pub fn max_out(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns the 'a' Input of this 'QuantizedMatMulWithBias' operation.
    pub fn a(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'b' Input of this 'QuantizedMatMulWithBias' operation.
    pub fn b(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'bias' Input of this 'QuantizedMatMulWithBias' operation.
    pub fn bias(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'min_a' Input of this 'QuantizedMatMulWithBias' operation.
    pub fn min_a(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'max_a' Input of this 'QuantizedMatMulWithBias' operation.
    pub fn max_a(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
    /// Returns the 'min_b' Input of this 'QuantizedMatMulWithBias' operation.
    pub fn min_b(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 5,
        }
    }
    /// Returns the 'max_b' Input of this 'QuantizedMatMulWithBias' operation.
    pub fn max_b(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 6,
        }
    }
}
impl From<QuantizedMatMulWithBiasInst> for crate::Operation {
    fn from(inst: QuantizedMatMulWithBiasInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `QuantizedMatMulWithBias::new().build(a, b, bias, min_a, max_a, min_b, max_b, scope)`.
pub fn quantized_mat_mul_with_bias<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
    O6: ::std::convert::Into<crate::Output>,
>(
    a: O0,
    b: O1,
    bias: O2,
    min_a: O3,
    max_a: O4,
    min_b: O5,
    max_b: O6,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    QuantizedMatMulWithBias::new().build(a, b, bias, min_a, max_a, min_b, max_b, scope)
}

/// Builder for the `QuantizedMatMulWithBiasAndDequantize` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct QuantizedMatMulWithBiasAndDequantize {
    T1: ::std::option::Option<crate::DataType>,
    T2: ::std::option::Option<crate::DataType>,
    Tbias: ::std::option::Option<crate::DataType>,
    Toutput: ::std::option::Option<crate::DataType>,
    transpose_a: ::std::option::Option<bool>,
    transpose_b: ::std::option::Option<bool>,
    input_quant_mode: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'QuantizedMatMulWithBiasAndDequantize' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct QuantizedMatMulWithBiasAndDequantizeInst {
    /// An instance of a fully built QuantizedMatMulWithBiasAndDequantize Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl QuantizedMatMulWithBiasAndDequantize {
    /// Creates a new `QuantizedMatMulWithBiasAndDequantize`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T1` attribute.
    pub fn T1<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T1 = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T2` attribute.
    pub fn T2<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T2 = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tbias` attribute.
    pub fn Tbias<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Tbias = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Toutput` attribute.
    pub fn Toutput<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Toutput = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `transpose_a` attribute.
    pub fn transpose_a<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.transpose_a = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `transpose_b` attribute.
    pub fn transpose_b<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.transpose_b = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `input_quant_mode` attribute.
    pub fn input_quant_mode<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.input_quant_mode = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `QuantizedMatMulWithBiasAndDequantize` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
        O6: ::std::convert::Into<crate::Output>,
        O7: ::std::convert::Into<crate::Output>,
        O8: ::std::convert::Into<crate::Output>,
    >(
        &self,
        a: O0,
        b: O1,
        bias: O2,
        min_a: O3,
        max_a: O4,
        min_b: O5,
        max_b: O6,
        min_freezed_output: O7,
        max_freezed_output: O8,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            a.into(),
            b.into(),
            bias.into(),
            min_a.into(),
            max_a.into(),
            min_b.into(),
            max_b.into(),
            min_freezed_output.into(),
            max_freezed_output.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        a: crate::Output,
        b: crate::Output,
        bias: crate::Output,
        min_a: crate::Output,
        max_a: crate::Output,
        min_b: crate::Output,
        max_b: crate::Output,
        min_freezed_output: crate::Output,
        max_freezed_output: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("QuantizedMatMulWithBiasAndDequantize", |nd| {
            nd.add_input(a);
            nd.add_input(b);
            nd.add_input(bias);
            nd.add_input(min_a);
            nd.add_input(max_a);
            nd.add_input(min_b);
            nd.add_input(max_b);
            nd.add_input(min_freezed_output);
            nd.add_input(max_freezed_output);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T1 {
                nd.set_attr_type("T1", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T2 {
                nd.set_attr_type("T2", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tbias {
                nd.set_attr_type("Tbias", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Toutput {
                nd.set_attr_type("Toutput", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.transpose_a {
                nd.set_attr_bool("transpose_a", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.transpose_b {
                nd.set_attr_bool("transpose_b", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.input_quant_mode {
                nd.set_attr_string("input_quant_mode", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'QuantizedMatMulWithBiasAndDequantize' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        a: crate::Output,
        b: crate::Output,
        bias: crate::Output,
        min_a: crate::Output,
        max_a: crate::Output,
        min_b: crate::Output,
        max_b: crate::Output,
        min_freezed_output: crate::Output,
        max_freezed_output: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<QuantizedMatMulWithBiasAndDequantizeInst> {
        let op = scope.new_operation("QuantizedMatMulWithBiasAndDequantize", |builder| {
            builder.add_input(a);
            builder.add_input(b);
            builder.add_input(bias);
            builder.add_input(min_a);
            builder.add_input(max_a);
            builder.add_input(min_b);
            builder.add_input(max_b);
            builder.add_input(min_freezed_output);
            builder.add_input(max_freezed_output);
            if let ::std::option::Option::Some(value) = &self.T1 {
                builder.set_attr_type("T1", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T2 {
                builder.set_attr_type("T2", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tbias {
                builder.set_attr_type("Tbias", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Toutput {
                builder.set_attr_type("Toutput", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.transpose_a {
                builder.set_attr_bool("transpose_a", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.transpose_b {
                builder.set_attr_bool("transpose_b", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.input_quant_mode {
                builder.set_attr_string("input_quant_mode", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(QuantizedMatMulWithBiasAndDequantizeInst { op })
    }
}
impl QuantizedMatMulWithBiasAndDequantizeInst {
    /// Returns the 'out' Output of this 'QuantizedMatMulWithBiasAndDequantize' operation.
    pub fn out(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'a' Input of this 'QuantizedMatMulWithBiasAndDequantize' operation.
    pub fn a(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'b' Input of this 'QuantizedMatMulWithBiasAndDequantize' operation.
    pub fn b(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'bias' Input of this 'QuantizedMatMulWithBiasAndDequantize' operation.
    pub fn bias(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'min_a' Input of this 'QuantizedMatMulWithBiasAndDequantize' operation.
    pub fn min_a(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'max_a' Input of this 'QuantizedMatMulWithBiasAndDequantize' operation.
    pub fn max_a(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
    /// Returns the 'min_b' Input of this 'QuantizedMatMulWithBiasAndDequantize' operation.
    pub fn min_b(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 5,
        }
    }
    /// Returns the 'max_b' Input of this 'QuantizedMatMulWithBiasAndDequantize' operation.
    pub fn max_b(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 6,
        }
    }
    /// Returns the 'min_freezed_output' Input of this 'QuantizedMatMulWithBiasAndDequantize' operation.
    pub fn min_freezed_output(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 7,
        }
    }
    /// Returns the 'max_freezed_output' Input of this 'QuantizedMatMulWithBiasAndDequantize' operation.
    pub fn max_freezed_output(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 8,
        }
    }
}
impl From<QuantizedMatMulWithBiasAndDequantizeInst> for crate::Operation {
    fn from(inst: QuantizedMatMulWithBiasAndDequantizeInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `QuantizedMatMulWithBiasAndDequantize::new().build(a, b, bias, min_a, max_a, min_b, max_b, min_freezed_output, max_freezed_output, scope)`.
pub fn quantized_mat_mul_with_bias_and_dequantize<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
    O6: ::std::convert::Into<crate::Output>,
    O7: ::std::convert::Into<crate::Output>,
    O8: ::std::convert::Into<crate::Output>,
>(
    a: O0,
    b: O1,
    bias: O2,
    min_a: O3,
    max_a: O4,
    min_b: O5,
    max_b: O6,
    min_freezed_output: O7,
    max_freezed_output: O8,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    QuantizedMatMulWithBiasAndDequantize::new().build(
        a,
        b,
        bias,
        min_a,
        max_a,
        min_b,
        max_b,
        min_freezed_output,
        max_freezed_output,
        scope,
    )
}

/// Builder for the `QuantizedMatMulWithBiasAndRelu` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct QuantizedMatMulWithBiasAndRelu {
    T1: ::std::option::Option<crate::DataType>,
    T2: ::std::option::Option<crate::DataType>,
    Toutput: ::std::option::Option<crate::DataType>,
    transpose_a: ::std::option::Option<bool>,
    transpose_b: ::std::option::Option<bool>,
    input_quant_mode: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'QuantizedMatMulWithBiasAndRelu' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct QuantizedMatMulWithBiasAndReluInst {
    /// An instance of a fully built QuantizedMatMulWithBiasAndRelu Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl QuantizedMatMulWithBiasAndRelu {
    /// Creates a new `QuantizedMatMulWithBiasAndRelu`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T1` attribute.
    pub fn T1<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T1 = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T2` attribute.
    pub fn T2<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T2 = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Toutput` attribute.
    pub fn Toutput<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Toutput = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `transpose_a` attribute.
    pub fn transpose_a<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.transpose_a = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `transpose_b` attribute.
    pub fn transpose_b<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.transpose_b = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `input_quant_mode` attribute.
    pub fn input_quant_mode<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.input_quant_mode = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `QuantizedMatMulWithBiasAndRelu` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
        O6: ::std::convert::Into<crate::Output>,
    >(
        &self,
        a: O0,
        b: O1,
        bias: O2,
        min_a: O3,
        max_a: O4,
        min_b: O5,
        max_b: O6,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            a.into(),
            b.into(),
            bias.into(),
            min_a.into(),
            max_a.into(),
            min_b.into(),
            max_b.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        a: crate::Output,
        b: crate::Output,
        bias: crate::Output,
        min_a: crate::Output,
        max_a: crate::Output,
        min_b: crate::Output,
        max_b: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("QuantizedMatMulWithBiasAndRelu", |nd| {
            nd.add_input(a);
            nd.add_input(b);
            nd.add_input(bias);
            nd.add_input(min_a);
            nd.add_input(max_a);
            nd.add_input(min_b);
            nd.add_input(max_b);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T1 {
                nd.set_attr_type("T1", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T2 {
                nd.set_attr_type("T2", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Toutput {
                nd.set_attr_type("Toutput", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.transpose_a {
                nd.set_attr_bool("transpose_a", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.transpose_b {
                nd.set_attr_bool("transpose_b", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.input_quant_mode {
                nd.set_attr_string("input_quant_mode", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'QuantizedMatMulWithBiasAndRelu' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        a: crate::Output,
        b: crate::Output,
        bias: crate::Output,
        min_a: crate::Output,
        max_a: crate::Output,
        min_b: crate::Output,
        max_b: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<QuantizedMatMulWithBiasAndReluInst> {
        let op = scope.new_operation("QuantizedMatMulWithBiasAndRelu", |builder| {
            builder.add_input(a);
            builder.add_input(b);
            builder.add_input(bias);
            builder.add_input(min_a);
            builder.add_input(max_a);
            builder.add_input(min_b);
            builder.add_input(max_b);
            if let ::std::option::Option::Some(value) = &self.T1 {
                builder.set_attr_type("T1", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T2 {
                builder.set_attr_type("T2", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Toutput {
                builder.set_attr_type("Toutput", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.transpose_a {
                builder.set_attr_bool("transpose_a", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.transpose_b {
                builder.set_attr_bool("transpose_b", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.input_quant_mode {
                builder.set_attr_string("input_quant_mode", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(QuantizedMatMulWithBiasAndReluInst { op })
    }
}
impl QuantizedMatMulWithBiasAndReluInst {
    /// Returns the 'out' Output of this 'QuantizedMatMulWithBiasAndRelu' operation.
    pub fn out(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'min_out' Output of this 'QuantizedMatMulWithBiasAndRelu' operation.
    pub fn min_out(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'max_out' Output of this 'QuantizedMatMulWithBiasAndRelu' operation.
    pub fn max_out(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns the 'a' Input of this 'QuantizedMatMulWithBiasAndRelu' operation.
    pub fn a(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'b' Input of this 'QuantizedMatMulWithBiasAndRelu' operation.
    pub fn b(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'bias' Input of this 'QuantizedMatMulWithBiasAndRelu' operation.
    pub fn bias(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'min_a' Input of this 'QuantizedMatMulWithBiasAndRelu' operation.
    pub fn min_a(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'max_a' Input of this 'QuantizedMatMulWithBiasAndRelu' operation.
    pub fn max_a(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
    /// Returns the 'min_b' Input of this 'QuantizedMatMulWithBiasAndRelu' operation.
    pub fn min_b(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 5,
        }
    }
    /// Returns the 'max_b' Input of this 'QuantizedMatMulWithBiasAndRelu' operation.
    pub fn max_b(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 6,
        }
    }
}
impl From<QuantizedMatMulWithBiasAndReluInst> for crate::Operation {
    fn from(inst: QuantizedMatMulWithBiasAndReluInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `QuantizedMatMulWithBiasAndRelu::new().build(a, b, bias, min_a, max_a, min_b, max_b, scope)`.
pub fn quantized_mat_mul_with_bias_and_relu<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
    O6: ::std::convert::Into<crate::Output>,
>(
    a: O0,
    b: O1,
    bias: O2,
    min_a: O3,
    max_a: O4,
    min_b: O5,
    max_b: O6,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    QuantizedMatMulWithBiasAndRelu::new().build(a, b, bias, min_a, max_a, min_b, max_b, scope)
}

/// Builder for the `QuantizedMatMulWithBiasAndReluAndRequantize` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct QuantizedMatMulWithBiasAndReluAndRequantize {
    T1: ::std::option::Option<crate::DataType>,
    T2: ::std::option::Option<crate::DataType>,
    Tbias: ::std::option::Option<crate::DataType>,
    Toutput: ::std::option::Option<crate::DataType>,
    transpose_a: ::std::option::Option<bool>,
    transpose_b: ::std::option::Option<bool>,
    input_quant_mode: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'QuantizedMatMulWithBiasAndReluAndRequantize' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct QuantizedMatMulWithBiasAndReluAndRequantizeInst {
    /// An instance of a fully built QuantizedMatMulWithBiasAndReluAndRequantize Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl QuantizedMatMulWithBiasAndReluAndRequantize {
    /// Creates a new `QuantizedMatMulWithBiasAndReluAndRequantize`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T1` attribute.
    pub fn T1<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T1 = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T2` attribute.
    pub fn T2<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T2 = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tbias` attribute.
    pub fn Tbias<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Tbias = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Toutput` attribute.
    pub fn Toutput<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Toutput = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `transpose_a` attribute.
    pub fn transpose_a<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.transpose_a = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `transpose_b` attribute.
    pub fn transpose_b<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.transpose_b = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `input_quant_mode` attribute.
    pub fn input_quant_mode<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.input_quant_mode = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `QuantizedMatMulWithBiasAndReluAndRequantize` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
        O6: ::std::convert::Into<crate::Output>,
        O7: ::std::convert::Into<crate::Output>,
        O8: ::std::convert::Into<crate::Output>,
    >(
        &self,
        a: O0,
        b: O1,
        bias: O2,
        min_a: O3,
        max_a: O4,
        min_b: O5,
        max_b: O6,
        min_freezed_output: O7,
        max_freezed_output: O8,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            a.into(),
            b.into(),
            bias.into(),
            min_a.into(),
            max_a.into(),
            min_b.into(),
            max_b.into(),
            min_freezed_output.into(),
            max_freezed_output.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        a: crate::Output,
        b: crate::Output,
        bias: crate::Output,
        min_a: crate::Output,
        max_a: crate::Output,
        min_b: crate::Output,
        max_b: crate::Output,
        min_freezed_output: crate::Output,
        max_freezed_output: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("QuantizedMatMulWithBiasAndReluAndRequantize", |nd| {
            nd.add_input(a);
            nd.add_input(b);
            nd.add_input(bias);
            nd.add_input(min_a);
            nd.add_input(max_a);
            nd.add_input(min_b);
            nd.add_input(max_b);
            nd.add_input(min_freezed_output);
            nd.add_input(max_freezed_output);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T1 {
                nd.set_attr_type("T1", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T2 {
                nd.set_attr_type("T2", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tbias {
                nd.set_attr_type("Tbias", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Toutput {
                nd.set_attr_type("Toutput", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.transpose_a {
                nd.set_attr_bool("transpose_a", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.transpose_b {
                nd.set_attr_bool("transpose_b", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.input_quant_mode {
                nd.set_attr_string("input_quant_mode", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'QuantizedMatMulWithBiasAndReluAndRequantize' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        a: crate::Output,
        b: crate::Output,
        bias: crate::Output,
        min_a: crate::Output,
        max_a: crate::Output,
        min_b: crate::Output,
        max_b: crate::Output,
        min_freezed_output: crate::Output,
        max_freezed_output: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<QuantizedMatMulWithBiasAndReluAndRequantizeInst> {
        let op = scope.new_operation("QuantizedMatMulWithBiasAndReluAndRequantize", |builder| {
            builder.add_input(a);
            builder.add_input(b);
            builder.add_input(bias);
            builder.add_input(min_a);
            builder.add_input(max_a);
            builder.add_input(min_b);
            builder.add_input(max_b);
            builder.add_input(min_freezed_output);
            builder.add_input(max_freezed_output);
            if let ::std::option::Option::Some(value) = &self.T1 {
                builder.set_attr_type("T1", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T2 {
                builder.set_attr_type("T2", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tbias {
                builder.set_attr_type("Tbias", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Toutput {
                builder.set_attr_type("Toutput", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.transpose_a {
                builder.set_attr_bool("transpose_a", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.transpose_b {
                builder.set_attr_bool("transpose_b", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.input_quant_mode {
                builder.set_attr_string("input_quant_mode", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(QuantizedMatMulWithBiasAndReluAndRequantizeInst { op })
    }
}
impl QuantizedMatMulWithBiasAndReluAndRequantizeInst {
    /// Returns the 'out' Output of this 'QuantizedMatMulWithBiasAndReluAndRequantize' operation.
    pub fn out(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'min_out' Output of this 'QuantizedMatMulWithBiasAndReluAndRequantize' operation.
    pub fn min_out(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'max_out' Output of this 'QuantizedMatMulWithBiasAndReluAndRequantize' operation.
    pub fn max_out(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns the 'a' Input of this 'QuantizedMatMulWithBiasAndReluAndRequantize' operation.
    pub fn a(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'b' Input of this 'QuantizedMatMulWithBiasAndReluAndRequantize' operation.
    pub fn b(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'bias' Input of this 'QuantizedMatMulWithBiasAndReluAndRequantize' operation.
    pub fn bias(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'min_a' Input of this 'QuantizedMatMulWithBiasAndReluAndRequantize' operation.
    pub fn min_a(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'max_a' Input of this 'QuantizedMatMulWithBiasAndReluAndRequantize' operation.
    pub fn max_a(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
    /// Returns the 'min_b' Input of this 'QuantizedMatMulWithBiasAndReluAndRequantize' operation.
    pub fn min_b(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 5,
        }
    }
    /// Returns the 'max_b' Input of this 'QuantizedMatMulWithBiasAndReluAndRequantize' operation.
    pub fn max_b(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 6,
        }
    }
    /// Returns the 'min_freezed_output' Input of this 'QuantizedMatMulWithBiasAndReluAndRequantize' operation.
    pub fn min_freezed_output(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 7,
        }
    }
    /// Returns the 'max_freezed_output' Input of this 'QuantizedMatMulWithBiasAndReluAndRequantize' operation.
    pub fn max_freezed_output(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 8,
        }
    }
}
impl From<QuantizedMatMulWithBiasAndReluAndRequantizeInst> for crate::Operation {
    fn from(inst: QuantizedMatMulWithBiasAndReluAndRequantizeInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `QuantizedMatMulWithBiasAndReluAndRequantize::new().build(a, b, bias, min_a, max_a, min_b, max_b, min_freezed_output, max_freezed_output, scope)`.
pub fn quantized_mat_mul_with_bias_and_relu_and_requantize<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
    O6: ::std::convert::Into<crate::Output>,
    O7: ::std::convert::Into<crate::Output>,
    O8: ::std::convert::Into<crate::Output>,
>(
    a: O0,
    b: O1,
    bias: O2,
    min_a: O3,
    max_a: O4,
    min_b: O5,
    max_b: O6,
    min_freezed_output: O7,
    max_freezed_output: O8,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    QuantizedMatMulWithBiasAndReluAndRequantize::new().build(
        a,
        b,
        bias,
        min_a,
        max_a,
        min_b,
        max_b,
        min_freezed_output,
        max_freezed_output,
        scope,
    )
}

/// Builder for the `QuantizedMatMulWithBiasAndRequantize` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct QuantizedMatMulWithBiasAndRequantize {
    T1: ::std::option::Option<crate::DataType>,
    T2: ::std::option::Option<crate::DataType>,
    Tbias: ::std::option::Option<crate::DataType>,
    Toutput: ::std::option::Option<crate::DataType>,
    transpose_a: ::std::option::Option<bool>,
    transpose_b: ::std::option::Option<bool>,
    input_quant_mode: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'QuantizedMatMulWithBiasAndRequantize' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct QuantizedMatMulWithBiasAndRequantizeInst {
    /// An instance of a fully built QuantizedMatMulWithBiasAndRequantize Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl QuantizedMatMulWithBiasAndRequantize {
    /// Creates a new `QuantizedMatMulWithBiasAndRequantize`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T1` attribute.
    pub fn T1<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T1 = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T2` attribute.
    pub fn T2<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T2 = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tbias` attribute.
    pub fn Tbias<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Tbias = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Toutput` attribute.
    pub fn Toutput<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Toutput = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `transpose_a` attribute.
    pub fn transpose_a<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.transpose_a = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `transpose_b` attribute.
    pub fn transpose_b<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.transpose_b = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `input_quant_mode` attribute.
    pub fn input_quant_mode<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.input_quant_mode = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `QuantizedMatMulWithBiasAndRequantize` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
        O6: ::std::convert::Into<crate::Output>,
        O7: ::std::convert::Into<crate::Output>,
        O8: ::std::convert::Into<crate::Output>,
    >(
        &self,
        a: O0,
        b: O1,
        bias: O2,
        min_a: O3,
        max_a: O4,
        min_b: O5,
        max_b: O6,
        min_freezed_output: O7,
        max_freezed_output: O8,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            a.into(),
            b.into(),
            bias.into(),
            min_a.into(),
            max_a.into(),
            min_b.into(),
            max_b.into(),
            min_freezed_output.into(),
            max_freezed_output.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        a: crate::Output,
        b: crate::Output,
        bias: crate::Output,
        min_a: crate::Output,
        max_a: crate::Output,
        min_b: crate::Output,
        max_b: crate::Output,
        min_freezed_output: crate::Output,
        max_freezed_output: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("QuantizedMatMulWithBiasAndRequantize", |nd| {
            nd.add_input(a);
            nd.add_input(b);
            nd.add_input(bias);
            nd.add_input(min_a);
            nd.add_input(max_a);
            nd.add_input(min_b);
            nd.add_input(max_b);
            nd.add_input(min_freezed_output);
            nd.add_input(max_freezed_output);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T1 {
                nd.set_attr_type("T1", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T2 {
                nd.set_attr_type("T2", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tbias {
                nd.set_attr_type("Tbias", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Toutput {
                nd.set_attr_type("Toutput", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.transpose_a {
                nd.set_attr_bool("transpose_a", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.transpose_b {
                nd.set_attr_bool("transpose_b", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.input_quant_mode {
                nd.set_attr_string("input_quant_mode", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'QuantizedMatMulWithBiasAndRequantize' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        a: crate::Output,
        b: crate::Output,
        bias: crate::Output,
        min_a: crate::Output,
        max_a: crate::Output,
        min_b: crate::Output,
        max_b: crate::Output,
        min_freezed_output: crate::Output,
        max_freezed_output: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<QuantizedMatMulWithBiasAndRequantizeInst> {
        let op = scope.new_operation("QuantizedMatMulWithBiasAndRequantize", |builder| {
            builder.add_input(a);
            builder.add_input(b);
            builder.add_input(bias);
            builder.add_input(min_a);
            builder.add_input(max_a);
            builder.add_input(min_b);
            builder.add_input(max_b);
            builder.add_input(min_freezed_output);
            builder.add_input(max_freezed_output);
            if let ::std::option::Option::Some(value) = &self.T1 {
                builder.set_attr_type("T1", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T2 {
                builder.set_attr_type("T2", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tbias {
                builder.set_attr_type("Tbias", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Toutput {
                builder.set_attr_type("Toutput", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.transpose_a {
                builder.set_attr_bool("transpose_a", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.transpose_b {
                builder.set_attr_bool("transpose_b", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.input_quant_mode {
                builder.set_attr_string("input_quant_mode", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(QuantizedMatMulWithBiasAndRequantizeInst { op })
    }
}
impl QuantizedMatMulWithBiasAndRequantizeInst {
    /// Returns the 'out' Output of this 'QuantizedMatMulWithBiasAndRequantize' operation.
    pub fn out(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'min_out' Output of this 'QuantizedMatMulWithBiasAndRequantize' operation.
    pub fn min_out(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'max_out' Output of this 'QuantizedMatMulWithBiasAndRequantize' operation.
    pub fn max_out(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns the 'a' Input of this 'QuantizedMatMulWithBiasAndRequantize' operation.
    pub fn a(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'b' Input of this 'QuantizedMatMulWithBiasAndRequantize' operation.
    pub fn b(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'bias' Input of this 'QuantizedMatMulWithBiasAndRequantize' operation.
    pub fn bias(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'min_a' Input of this 'QuantizedMatMulWithBiasAndRequantize' operation.
    pub fn min_a(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'max_a' Input of this 'QuantizedMatMulWithBiasAndRequantize' operation.
    pub fn max_a(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
    /// Returns the 'min_b' Input of this 'QuantizedMatMulWithBiasAndRequantize' operation.
    pub fn min_b(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 5,
        }
    }
    /// Returns the 'max_b' Input of this 'QuantizedMatMulWithBiasAndRequantize' operation.
    pub fn max_b(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 6,
        }
    }
    /// Returns the 'min_freezed_output' Input of this 'QuantizedMatMulWithBiasAndRequantize' operation.
    pub fn min_freezed_output(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 7,
        }
    }
    /// Returns the 'max_freezed_output' Input of this 'QuantizedMatMulWithBiasAndRequantize' operation.
    pub fn max_freezed_output(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 8,
        }
    }
}
impl From<QuantizedMatMulWithBiasAndRequantizeInst> for crate::Operation {
    fn from(inst: QuantizedMatMulWithBiasAndRequantizeInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `QuantizedMatMulWithBiasAndRequantize::new().build(a, b, bias, min_a, max_a, min_b, max_b, min_freezed_output, max_freezed_output, scope)`.
pub fn quantized_mat_mul_with_bias_and_requantize<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
    O6: ::std::convert::Into<crate::Output>,
    O7: ::std::convert::Into<crate::Output>,
    O8: ::std::convert::Into<crate::Output>,
>(
    a: O0,
    b: O1,
    bias: O2,
    min_a: O3,
    max_a: O4,
    min_b: O5,
    max_b: O6,
    min_freezed_output: O7,
    max_freezed_output: O8,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    QuantizedMatMulWithBiasAndRequantize::new().build(
        a,
        b,
        bias,
        min_a,
        max_a,
        min_b,
        max_b,
        min_freezed_output,
        max_freezed_output,
        scope,
    )
}

/// Builder for the `QuantizedMaxPool` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct QuantizedMaxPool {
    T: ::std::option::Option<crate::DataType>,
    ksize: ::std::option::Option<::std::vec::Vec<i64>>,
    strides: ::std::option::Option<::std::vec::Vec<i64>>,
    padding: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'QuantizedMaxPool' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct QuantizedMaxPoolInst {
    /// An instance of a fully built QuantizedMaxPool Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl QuantizedMaxPool {
    /// Creates a new `QuantizedMaxPool`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `ksize` attribute.
    pub fn ksize<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.ksize = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `strides` attribute.
    pub fn strides<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.strides = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `padding` attribute.
    pub fn padding<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.padding = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `QuantizedMaxPool` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        min_input: O1,
        max_input: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), min_input.into(), max_input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        min_input: crate::Output,
        max_input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("QuantizedMaxPool", |nd| {
            nd.add_input(input);
            nd.add_input(min_input);
            nd.add_input(max_input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.ksize {
                nd.set_attr_int_list("ksize", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.strides {
                nd.set_attr_int_list("strides", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding {
                nd.set_attr_string("padding", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'QuantizedMaxPool' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        min_input: crate::Output,
        max_input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<QuantizedMaxPoolInst> {
        let op = scope.new_operation("QuantizedMaxPool", |builder| {
            builder.add_input(input);
            builder.add_input(min_input);
            builder.add_input(max_input);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.ksize {
                builder.set_attr_int_list("ksize", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.strides {
                builder.set_attr_int_list("strides", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding {
                builder.set_attr_string("padding", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(QuantizedMaxPoolInst { op })
    }
}
impl QuantizedMaxPoolInst {
    /// Returns the 'output' Output of this 'QuantizedMaxPool' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'min_output' Output of this 'QuantizedMaxPool' operation.
    pub fn min_output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'max_output' Output of this 'QuantizedMaxPool' operation.
    pub fn max_output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns the 'input' Input of this 'QuantizedMaxPool' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'min_input' Input of this 'QuantizedMaxPool' operation.
    pub fn min_input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'max_input' Input of this 'QuantizedMaxPool' operation.
    pub fn max_input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<QuantizedMaxPoolInst> for crate::Operation {
    fn from(inst: QuantizedMaxPoolInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `QuantizedMaxPool::new().build(input, min_input, max_input, scope)`.
pub fn quantized_max_pool<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    input: O0,
    min_input: O1,
    max_input: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    QuantizedMaxPool::new().build(input, min_input, max_input, scope)
}

/// Builder for the `QuantizedMul` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct QuantizedMul {
    T1: ::std::option::Option<crate::DataType>,
    T2: ::std::option::Option<crate::DataType>,
    Toutput: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'QuantizedMul' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct QuantizedMulInst {
    /// An instance of a fully built QuantizedMul Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl QuantizedMul {
    /// Creates a new `QuantizedMul`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T1` attribute.
    pub fn T1<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T1 = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T2` attribute.
    pub fn T2<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T2 = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Toutput` attribute.
    pub fn Toutput<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Toutput = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `QuantizedMul` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
    >(
        &self,
        x: O0,
        y: O1,
        min_x: O2,
        max_x: O3,
        min_y: O4,
        max_y: O5,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            x.into(),
            y.into(),
            min_x.into(),
            max_x.into(),
            min_y.into(),
            max_y.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        x: crate::Output,
        y: crate::Output,
        min_x: crate::Output,
        max_x: crate::Output,
        min_y: crate::Output,
        max_y: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("QuantizedMul", |nd| {
            nd.add_input(x);
            nd.add_input(y);
            nd.add_input(min_x);
            nd.add_input(max_x);
            nd.add_input(min_y);
            nd.add_input(max_y);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T1 {
                nd.set_attr_type("T1", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T2 {
                nd.set_attr_type("T2", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Toutput {
                nd.set_attr_type("Toutput", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'QuantizedMul' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        y: crate::Output,
        min_x: crate::Output,
        max_x: crate::Output,
        min_y: crate::Output,
        max_y: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<QuantizedMulInst> {
        let op = scope.new_operation("QuantizedMul", |builder| {
            builder.add_input(x);
            builder.add_input(y);
            builder.add_input(min_x);
            builder.add_input(max_x);
            builder.add_input(min_y);
            builder.add_input(max_y);
            if let ::std::option::Option::Some(value) = &self.T1 {
                builder.set_attr_type("T1", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T2 {
                builder.set_attr_type("T2", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Toutput {
                builder.set_attr_type("Toutput", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(QuantizedMulInst { op })
    }
}
impl QuantizedMulInst {
    /// Returns the 'z' Output of this 'QuantizedMul' operation.
    pub fn z(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'min_z' Output of this 'QuantizedMul' operation.
    pub fn min_z(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'max_z' Output of this 'QuantizedMul' operation.
    pub fn max_z(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns the 'x' Input of this 'QuantizedMul' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'y' Input of this 'QuantizedMul' operation.
    pub fn y(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'min_x' Input of this 'QuantizedMul' operation.
    pub fn min_x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'max_x' Input of this 'QuantizedMul' operation.
    pub fn max_x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'min_y' Input of this 'QuantizedMul' operation.
    pub fn min_y(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
    /// Returns the 'max_y' Input of this 'QuantizedMul' operation.
    pub fn max_y(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 5,
        }
    }
}
impl From<QuantizedMulInst> for crate::Operation {
    fn from(inst: QuantizedMulInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `QuantizedMul::new().build(x, y, min_x, max_x, min_y, max_y, scope)`.
pub fn quantized_mul<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
>(
    x: O0,
    y: O1,
    min_x: O2,
    max_x: O3,
    min_y: O4,
    max_y: O5,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    QuantizedMul::new().build(x, y, min_x, max_x, min_y, max_y, scope)
}

/// Builder for the `QuantizedRelu` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct QuantizedRelu {
    Tinput: ::std::option::Option<crate::DataType>,
    out_type: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'QuantizedRelu' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct QuantizedReluInst {
    /// An instance of a fully built QuantizedRelu Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl QuantizedRelu {
    /// Creates a new `QuantizedRelu`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `Tinput` attribute.
    pub fn Tinput<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tinput = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `out_type` attribute.
    pub fn out_type<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.out_type = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `QuantizedRelu` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        features: O0,
        min_features: O1,
        max_features: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            features.into(),
            min_features.into(),
            max_features.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        features: crate::Output,
        min_features: crate::Output,
        max_features: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("QuantizedRelu", |nd| {
            nd.add_input(features);
            nd.add_input(min_features);
            nd.add_input(max_features);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.Tinput {
                nd.set_attr_type("Tinput", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.out_type {
                nd.set_attr_type("out_type", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'QuantizedRelu' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        features: crate::Output,
        min_features: crate::Output,
        max_features: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<QuantizedReluInst> {
        let op = scope.new_operation("QuantizedRelu", |builder| {
            builder.add_input(features);
            builder.add_input(min_features);
            builder.add_input(max_features);
            if let ::std::option::Option::Some(value) = &self.Tinput {
                builder.set_attr_type("Tinput", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.out_type {
                builder.set_attr_type("out_type", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(QuantizedReluInst { op })
    }
}
impl QuantizedReluInst {
    /// Returns the 'activations' Output of this 'QuantizedRelu' operation.
    pub fn activations(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'min_activations' Output of this 'QuantizedRelu' operation.
    pub fn min_activations(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'max_activations' Output of this 'QuantizedRelu' operation.
    pub fn max_activations(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns the 'features' Input of this 'QuantizedRelu' operation.
    pub fn features(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'min_features' Input of this 'QuantizedRelu' operation.
    pub fn min_features(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'max_features' Input of this 'QuantizedRelu' operation.
    pub fn max_features(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<QuantizedReluInst> for crate::Operation {
    fn from(inst: QuantizedReluInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `QuantizedRelu::new().build(features, min_features, max_features, scope)`.
pub fn quantized_relu<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    features: O0,
    min_features: O1,
    max_features: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    QuantizedRelu::new().build(features, min_features, max_features, scope)
}

/// Builder for the `QuantizedRelu6` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct QuantizedRelu6 {
    Tinput: ::std::option::Option<crate::DataType>,
    out_type: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'QuantizedRelu6' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct QuantizedRelu6Inst {
    /// An instance of a fully built QuantizedRelu6 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl QuantizedRelu6 {
    /// Creates a new `QuantizedRelu6`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `Tinput` attribute.
    pub fn Tinput<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tinput = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `out_type` attribute.
    pub fn out_type<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.out_type = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `QuantizedRelu6` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        features: O0,
        min_features: O1,
        max_features: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            features.into(),
            min_features.into(),
            max_features.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        features: crate::Output,
        min_features: crate::Output,
        max_features: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("QuantizedRelu6", |nd| {
            nd.add_input(features);
            nd.add_input(min_features);
            nd.add_input(max_features);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.Tinput {
                nd.set_attr_type("Tinput", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.out_type {
                nd.set_attr_type("out_type", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'QuantizedRelu6' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        features: crate::Output,
        min_features: crate::Output,
        max_features: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<QuantizedRelu6Inst> {
        let op = scope.new_operation("QuantizedRelu6", |builder| {
            builder.add_input(features);
            builder.add_input(min_features);
            builder.add_input(max_features);
            if let ::std::option::Option::Some(value) = &self.Tinput {
                builder.set_attr_type("Tinput", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.out_type {
                builder.set_attr_type("out_type", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(QuantizedRelu6Inst { op })
    }
}
impl QuantizedRelu6Inst {
    /// Returns the 'activations' Output of this 'QuantizedRelu6' operation.
    pub fn activations(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'min_activations' Output of this 'QuantizedRelu6' operation.
    pub fn min_activations(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'max_activations' Output of this 'QuantizedRelu6' operation.
    pub fn max_activations(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns the 'features' Input of this 'QuantizedRelu6' operation.
    pub fn features(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'min_features' Input of this 'QuantizedRelu6' operation.
    pub fn min_features(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'max_features' Input of this 'QuantizedRelu6' operation.
    pub fn max_features(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<QuantizedRelu6Inst> for crate::Operation {
    fn from(inst: QuantizedRelu6Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `QuantizedRelu6::new().build(features, min_features, max_features, scope)`.
pub fn quantized_relu6<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    features: O0,
    min_features: O1,
    max_features: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    QuantizedRelu6::new().build(features, min_features, max_features, scope)
}

/// Builder for the `QuantizedReluX` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct QuantizedReluX {
    Tinput: ::std::option::Option<crate::DataType>,
    out_type: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'QuantizedReluX' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct QuantizedReluXInst {
    /// An instance of a fully built QuantizedReluX Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl QuantizedReluX {
    /// Creates a new `QuantizedReluX`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `Tinput` attribute.
    pub fn Tinput<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tinput = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `out_type` attribute.
    pub fn out_type<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.out_type = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `QuantizedReluX` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
    >(
        &self,
        features: O0,
        max_value: O1,
        min_features: O2,
        max_features: O3,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            features.into(),
            max_value.into(),
            min_features.into(),
            max_features.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        features: crate::Output,
        max_value: crate::Output,
        min_features: crate::Output,
        max_features: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("QuantizedReluX", |nd| {
            nd.add_input(features);
            nd.add_input(max_value);
            nd.add_input(min_features);
            nd.add_input(max_features);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.Tinput {
                nd.set_attr_type("Tinput", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.out_type {
                nd.set_attr_type("out_type", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'QuantizedReluX' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        features: crate::Output,
        max_value: crate::Output,
        min_features: crate::Output,
        max_features: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<QuantizedReluXInst> {
        let op = scope.new_operation("QuantizedReluX", |builder| {
            builder.add_input(features);
            builder.add_input(max_value);
            builder.add_input(min_features);
            builder.add_input(max_features);
            if let ::std::option::Option::Some(value) = &self.Tinput {
                builder.set_attr_type("Tinput", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.out_type {
                builder.set_attr_type("out_type", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(QuantizedReluXInst { op })
    }
}
impl QuantizedReluXInst {
    /// Returns the 'activations' Output of this 'QuantizedReluX' operation.
    pub fn activations(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'min_activations' Output of this 'QuantizedReluX' operation.
    pub fn min_activations(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'max_activations' Output of this 'QuantizedReluX' operation.
    pub fn max_activations(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns the 'features' Input of this 'QuantizedReluX' operation.
    pub fn features(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'max_value' Input of this 'QuantizedReluX' operation.
    pub fn max_value(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'min_features' Input of this 'QuantizedReluX' operation.
    pub fn min_features(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'max_features' Input of this 'QuantizedReluX' operation.
    pub fn max_features(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
}
impl From<QuantizedReluXInst> for crate::Operation {
    fn from(inst: QuantizedReluXInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `QuantizedReluX::new().build(features, max_value, min_features, max_features, scope)`.
pub fn quantized_relu_x<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
>(
    features: O0,
    max_value: O1,
    min_features: O2,
    max_features: O3,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    QuantizedReluX::new().build(features, max_value, min_features, max_features, scope)
}

/// Builder for the `QuantizedReshape` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct QuantizedReshape {
    T: ::std::option::Option<crate::DataType>,
    Tshape: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'QuantizedReshape' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct QuantizedReshapeInst {
    /// An instance of a fully built QuantizedReshape Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl QuantizedReshape {
    /// Creates a new `QuantizedReshape`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tshape` attribute.
    pub fn Tshape<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tshape = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `QuantizedReshape` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
    >(
        &self,
        tensor: O0,
        shape: O1,
        input_min: O2,
        input_max: O3,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            tensor.into(),
            shape.into(),
            input_min.into(),
            input_max.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        tensor: crate::Output,
        shape: crate::Output,
        input_min: crate::Output,
        input_max: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("QuantizedReshape", |nd| {
            nd.add_input(tensor);
            nd.add_input(shape);
            nd.add_input(input_min);
            nd.add_input(input_max);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tshape {
                nd.set_attr_type("Tshape", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'QuantizedReshape' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        tensor: crate::Output,
        shape: crate::Output,
        input_min: crate::Output,
        input_max: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<QuantizedReshapeInst> {
        let op = scope.new_operation("QuantizedReshape", |builder| {
            builder.add_input(tensor);
            builder.add_input(shape);
            builder.add_input(input_min);
            builder.add_input(input_max);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tshape {
                builder.set_attr_type("Tshape", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(QuantizedReshapeInst { op })
    }
}
impl QuantizedReshapeInst {
    /// Returns the 'output' Output of this 'QuantizedReshape' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'output_min' Output of this 'QuantizedReshape' operation.
    pub fn output_min(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'output_max' Output of this 'QuantizedReshape' operation.
    pub fn output_max(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns the 'tensor' Input of this 'QuantizedReshape' operation.
    pub fn tensor(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'shape' Input of this 'QuantizedReshape' operation.
    pub fn shape(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'input_min' Input of this 'QuantizedReshape' operation.
    pub fn input_min(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'input_max' Input of this 'QuantizedReshape' operation.
    pub fn input_max(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
}
impl From<QuantizedReshapeInst> for crate::Operation {
    fn from(inst: QuantizedReshapeInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `QuantizedReshape::new().build(tensor, shape, input_min, input_max, scope)`.
pub fn quantized_reshape<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
>(
    tensor: O0,
    shape: O1,
    input_min: O2,
    input_max: O3,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    QuantizedReshape::new().build(tensor, shape, input_min, input_max, scope)
}

/// Builder for the `QuantizedResizeBilinear` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct QuantizedResizeBilinear {
    T: ::std::option::Option<crate::DataType>,
    align_corners: ::std::option::Option<bool>,
    half_pixel_centers: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'QuantizedResizeBilinear' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct QuantizedResizeBilinearInst {
    /// An instance of a fully built QuantizedResizeBilinear Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl QuantizedResizeBilinear {
    /// Creates a new `QuantizedResizeBilinear`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `align_corners` attribute.
    pub fn align_corners<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.align_corners = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `half_pixel_centers` attribute.
    pub fn half_pixel_centers<ArgType: ::std::convert::Into<bool>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.half_pixel_centers = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `QuantizedResizeBilinear` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
    >(
        &self,
        images: O0,
        size: O1,
        min: O2,
        max: O3,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(images.into(), size.into(), min.into(), max.into(), scope)
    }
    fn build_impl(
        &self,
        images: crate::Output,
        size: crate::Output,
        min: crate::Output,
        max: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("QuantizedResizeBilinear", |nd| {
            nd.add_input(images);
            nd.add_input(size);
            nd.add_input(min);
            nd.add_input(max);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.align_corners {
                nd.set_attr_bool("align_corners", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.half_pixel_centers {
                nd.set_attr_bool("half_pixel_centers", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'QuantizedResizeBilinear' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        images: crate::Output,
        size: crate::Output,
        min: crate::Output,
        max: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<QuantizedResizeBilinearInst> {
        let op = scope.new_operation("QuantizedResizeBilinear", |builder| {
            builder.add_input(images);
            builder.add_input(size);
            builder.add_input(min);
            builder.add_input(max);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.align_corners {
                builder.set_attr_bool("align_corners", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.half_pixel_centers {
                builder.set_attr_bool("half_pixel_centers", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(QuantizedResizeBilinearInst { op })
    }
}
impl QuantizedResizeBilinearInst {
    /// Returns the 'resized_images' Output of this 'QuantizedResizeBilinear' operation.
    pub fn resized_images(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'out_min' Output of this 'QuantizedResizeBilinear' operation.
    pub fn out_min(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'out_max' Output of this 'QuantizedResizeBilinear' operation.
    pub fn out_max(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns the 'images' Input of this 'QuantizedResizeBilinear' operation.
    pub fn images(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'size' Input of this 'QuantizedResizeBilinear' operation.
    pub fn size(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'min' Input of this 'QuantizedResizeBilinear' operation.
    pub fn min(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'max' Input of this 'QuantizedResizeBilinear' operation.
    pub fn max(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
}
impl From<QuantizedResizeBilinearInst> for crate::Operation {
    fn from(inst: QuantizedResizeBilinearInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `QuantizedResizeBilinear::new().build(images, size, min, max, scope)`.
pub fn quantized_resize_bilinear<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
>(
    images: O0,
    size: O1,
    min: O2,
    max: O3,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    QuantizedResizeBilinear::new().build(images, size, min, max, scope)
}

/// Builder for the `QueueClose` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct QueueClose {
    cancel_pending_enqueues: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'QueueClose' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct QueueCloseInst {
    /// An instance of a fully built QueueClose Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl QueueClose {
    /// Creates a new `QueueClose`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `cancel_pending_enqueues` attribute.
    pub fn cancel_pending_enqueues<ArgType: ::std::convert::Into<bool>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.cancel_pending_enqueues = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `QueueClose` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        handle: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(handle.into(), scope)
    }
    fn build_impl(
        &self,
        handle: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("QueueClose", |nd| {
            nd.add_input(handle);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.cancel_pending_enqueues {
                nd.set_attr_bool("cancel_pending_enqueues", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'QueueClose' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        handle: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<QueueCloseInst> {
        let op = scope.new_operation("QueueClose", |builder| {
            builder.add_input(handle);
            if let ::std::option::Option::Some(value) = &self.cancel_pending_enqueues {
                builder.set_attr_bool("cancel_pending_enqueues", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(QueueCloseInst { op })
    }
}
impl QueueCloseInst {
    /// Returns the 'handle' Input of this 'QueueClose' operation.
    pub fn handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<QueueCloseInst> for crate::Operation {
    fn from(inst: QueueCloseInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `QueueClose::new().build(handle, scope)`.
pub fn queue_close<O0: ::std::convert::Into<crate::Output>>(
    handle: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    QueueClose::new().build(handle, scope)
}

/// Builder for the `QueueCloseV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct QueueCloseV2 {
    cancel_pending_enqueues: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'QueueCloseV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct QueueCloseV2Inst {
    /// An instance of a fully built QueueCloseV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl QueueCloseV2 {
    /// Creates a new `QueueCloseV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `cancel_pending_enqueues` attribute.
    pub fn cancel_pending_enqueues<ArgType: ::std::convert::Into<bool>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.cancel_pending_enqueues = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `QueueCloseV2` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        handle: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(handle.into(), scope)
    }
    fn build_impl(
        &self,
        handle: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("QueueCloseV2", |nd| {
            nd.add_input(handle);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.cancel_pending_enqueues {
                nd.set_attr_bool("cancel_pending_enqueues", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'QueueCloseV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        handle: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<QueueCloseV2Inst> {
        let op = scope.new_operation("QueueCloseV2", |builder| {
            builder.add_input(handle);
            if let ::std::option::Option::Some(value) = &self.cancel_pending_enqueues {
                builder.set_attr_bool("cancel_pending_enqueues", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(QueueCloseV2Inst { op })
    }
}
impl QueueCloseV2Inst {
    /// Returns the 'handle' Input of this 'QueueCloseV2' operation.
    pub fn handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<QueueCloseV2Inst> for crate::Operation {
    fn from(inst: QueueCloseV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `QueueCloseV2::new().build(handle, scope)`.
pub fn queue_close_v2<O0: ::std::convert::Into<crate::Output>>(
    handle: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    QueueCloseV2::new().build(handle, scope)
}

/// Builder for the `QueueDequeue` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct QueueDequeue {
    component_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    timeout_ms: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'QueueDequeue' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct QueueDequeueInst {
    /// An instance of a fully built QueueDequeue Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl QueueDequeue {
    /// Creates a new `QueueDequeue`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `component_types` attribute.
    pub fn component_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.component_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `timeout_ms` attribute.
    pub fn timeout_ms<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.timeout_ms = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `QueueDequeue` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        handle: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(handle.into(), scope)
    }
    fn build_impl(
        &self,
        handle: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("QueueDequeue", |nd| {
            nd.add_input(handle);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.component_types {
                nd.set_attr_type_list("component_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.timeout_ms {
                nd.set_attr_int("timeout_ms", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'QueueDequeue' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        handle: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<QueueDequeueInst> {
        let op = scope.new_operation("QueueDequeue", |builder| {
            builder.add_input(handle);
            if let ::std::option::Option::Some(value) = &self.component_types {
                builder.set_attr_type_list("component_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.timeout_ms {
                builder.set_attr_int("timeout_ms", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(QueueDequeueInst { op })
    }
}
impl QueueDequeueInst {
    /// Returns the 'components' Output of this 'QueueDequeue' operation.
    pub fn components(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'handle' Input of this 'QueueDequeue' operation.
    pub fn handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<QueueDequeueInst> for crate::Operation {
    fn from(inst: QueueDequeueInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `QueueDequeue::new().build(handle, scope)`.
pub fn queue_dequeue<O0: ::std::convert::Into<crate::Output>>(
    handle: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    QueueDequeue::new().build(handle, scope)
}

/// Builder for the `QueueDequeueMany` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct QueueDequeueMany {
    component_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    timeout_ms: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'QueueDequeueMany' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct QueueDequeueManyInst {
    /// An instance of a fully built QueueDequeueMany Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl QueueDequeueMany {
    /// Creates a new `QueueDequeueMany`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `component_types` attribute.
    pub fn component_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.component_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `timeout_ms` attribute.
    pub fn timeout_ms<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.timeout_ms = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `QueueDequeueMany` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        handle: O0,
        n: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(handle.into(), n.into(), scope)
    }
    fn build_impl(
        &self,
        handle: crate::Output,
        n: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("QueueDequeueMany", |nd| {
            nd.add_input(handle);
            nd.add_input(n);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.component_types {
                nd.set_attr_type_list("component_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.timeout_ms {
                nd.set_attr_int("timeout_ms", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'QueueDequeueMany' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        handle: crate::Output,
        n: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<QueueDequeueManyInst> {
        let op = scope.new_operation("QueueDequeueMany", |builder| {
            builder.add_input(handle);
            builder.add_input(n);
            if let ::std::option::Option::Some(value) = &self.component_types {
                builder.set_attr_type_list("component_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.timeout_ms {
                builder.set_attr_int("timeout_ms", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(QueueDequeueManyInst { op })
    }
}
impl QueueDequeueManyInst {
    /// Returns the 'components' Output of this 'QueueDequeueMany' operation.
    pub fn components(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'handle' Input of this 'QueueDequeueMany' operation.
    pub fn handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'n' Input of this 'QueueDequeueMany' operation.
    pub fn n(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<QueueDequeueManyInst> for crate::Operation {
    fn from(inst: QueueDequeueManyInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `QueueDequeueMany::new().build(handle, n, scope)`.
pub fn queue_dequeue_many<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    handle: O0,
    n: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    QueueDequeueMany::new().build(handle, n, scope)
}

/// Builder for the `QueueDequeueManyV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct QueueDequeueManyV2 {
    component_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    timeout_ms: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'QueueDequeueManyV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct QueueDequeueManyV2Inst {
    /// An instance of a fully built QueueDequeueManyV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl QueueDequeueManyV2 {
    /// Creates a new `QueueDequeueManyV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `component_types` attribute.
    pub fn component_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.component_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `timeout_ms` attribute.
    pub fn timeout_ms<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.timeout_ms = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `QueueDequeueManyV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        handle: O0,
        n: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(handle.into(), n.into(), scope)
    }
    fn build_impl(
        &self,
        handle: crate::Output,
        n: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("QueueDequeueManyV2", |nd| {
            nd.add_input(handle);
            nd.add_input(n);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.component_types {
                nd.set_attr_type_list("component_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.timeout_ms {
                nd.set_attr_int("timeout_ms", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'QueueDequeueManyV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        handle: crate::Output,
        n: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<QueueDequeueManyV2Inst> {
        let op = scope.new_operation("QueueDequeueManyV2", |builder| {
            builder.add_input(handle);
            builder.add_input(n);
            if let ::std::option::Option::Some(value) = &self.component_types {
                builder.set_attr_type_list("component_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.timeout_ms {
                builder.set_attr_int("timeout_ms", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(QueueDequeueManyV2Inst { op })
    }
}
impl QueueDequeueManyV2Inst {
    /// Returns the 'components' Output of this 'QueueDequeueManyV2' operation.
    pub fn components(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'handle' Input of this 'QueueDequeueManyV2' operation.
    pub fn handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'n' Input of this 'QueueDequeueManyV2' operation.
    pub fn n(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<QueueDequeueManyV2Inst> for crate::Operation {
    fn from(inst: QueueDequeueManyV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `QueueDequeueManyV2::new().build(handle, n, scope)`.
pub fn queue_dequeue_many_v2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    handle: O0,
    n: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    QueueDequeueManyV2::new().build(handle, n, scope)
}

/// Builder for the `QueueDequeueUpTo` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct QueueDequeueUpTo {
    component_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    timeout_ms: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'QueueDequeueUpTo' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct QueueDequeueUpToInst {
    /// An instance of a fully built QueueDequeueUpTo Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl QueueDequeueUpTo {
    /// Creates a new `QueueDequeueUpTo`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `component_types` attribute.
    pub fn component_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.component_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `timeout_ms` attribute.
    pub fn timeout_ms<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.timeout_ms = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `QueueDequeueUpTo` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        handle: O0,
        n: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(handle.into(), n.into(), scope)
    }
    fn build_impl(
        &self,
        handle: crate::Output,
        n: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("QueueDequeueUpTo", |nd| {
            nd.add_input(handle);
            nd.add_input(n);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.component_types {
                nd.set_attr_type_list("component_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.timeout_ms {
                nd.set_attr_int("timeout_ms", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'QueueDequeueUpTo' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        handle: crate::Output,
        n: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<QueueDequeueUpToInst> {
        let op = scope.new_operation("QueueDequeueUpTo", |builder| {
            builder.add_input(handle);
            builder.add_input(n);
            if let ::std::option::Option::Some(value) = &self.component_types {
                builder.set_attr_type_list("component_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.timeout_ms {
                builder.set_attr_int("timeout_ms", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(QueueDequeueUpToInst { op })
    }
}
impl QueueDequeueUpToInst {
    /// Returns the 'components' Output of this 'QueueDequeueUpTo' operation.
    pub fn components(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'handle' Input of this 'QueueDequeueUpTo' operation.
    pub fn handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'n' Input of this 'QueueDequeueUpTo' operation.
    pub fn n(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<QueueDequeueUpToInst> for crate::Operation {
    fn from(inst: QueueDequeueUpToInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `QueueDequeueUpTo::new().build(handle, n, scope)`.
pub fn queue_dequeue_up_to<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    handle: O0,
    n: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    QueueDequeueUpTo::new().build(handle, n, scope)
}

/// Builder for the `QueueDequeueUpToV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct QueueDequeueUpToV2 {
    component_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    timeout_ms: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'QueueDequeueUpToV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct QueueDequeueUpToV2Inst {
    /// An instance of a fully built QueueDequeueUpToV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl QueueDequeueUpToV2 {
    /// Creates a new `QueueDequeueUpToV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `component_types` attribute.
    pub fn component_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.component_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `timeout_ms` attribute.
    pub fn timeout_ms<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.timeout_ms = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `QueueDequeueUpToV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        handle: O0,
        n: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(handle.into(), n.into(), scope)
    }
    fn build_impl(
        &self,
        handle: crate::Output,
        n: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("QueueDequeueUpToV2", |nd| {
            nd.add_input(handle);
            nd.add_input(n);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.component_types {
                nd.set_attr_type_list("component_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.timeout_ms {
                nd.set_attr_int("timeout_ms", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'QueueDequeueUpToV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        handle: crate::Output,
        n: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<QueueDequeueUpToV2Inst> {
        let op = scope.new_operation("QueueDequeueUpToV2", |builder| {
            builder.add_input(handle);
            builder.add_input(n);
            if let ::std::option::Option::Some(value) = &self.component_types {
                builder.set_attr_type_list("component_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.timeout_ms {
                builder.set_attr_int("timeout_ms", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(QueueDequeueUpToV2Inst { op })
    }
}
impl QueueDequeueUpToV2Inst {
    /// Returns the 'components' Output of this 'QueueDequeueUpToV2' operation.
    pub fn components(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'handle' Input of this 'QueueDequeueUpToV2' operation.
    pub fn handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'n' Input of this 'QueueDequeueUpToV2' operation.
    pub fn n(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<QueueDequeueUpToV2Inst> for crate::Operation {
    fn from(inst: QueueDequeueUpToV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `QueueDequeueUpToV2::new().build(handle, n, scope)`.
pub fn queue_dequeue_up_to_v2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    handle: O0,
    n: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    QueueDequeueUpToV2::new().build(handle, n, scope)
}

/// Builder for the `QueueDequeueV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct QueueDequeueV2 {
    component_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    timeout_ms: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'QueueDequeueV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct QueueDequeueV2Inst {
    /// An instance of a fully built QueueDequeueV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl QueueDequeueV2 {
    /// Creates a new `QueueDequeueV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `component_types` attribute.
    pub fn component_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.component_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `timeout_ms` attribute.
    pub fn timeout_ms<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.timeout_ms = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `QueueDequeueV2` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        handle: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(handle.into(), scope)
    }
    fn build_impl(
        &self,
        handle: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("QueueDequeueV2", |nd| {
            nd.add_input(handle);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.component_types {
                nd.set_attr_type_list("component_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.timeout_ms {
                nd.set_attr_int("timeout_ms", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'QueueDequeueV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        handle: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<QueueDequeueV2Inst> {
        let op = scope.new_operation("QueueDequeueV2", |builder| {
            builder.add_input(handle);
            if let ::std::option::Option::Some(value) = &self.component_types {
                builder.set_attr_type_list("component_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.timeout_ms {
                builder.set_attr_int("timeout_ms", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(QueueDequeueV2Inst { op })
    }
}
impl QueueDequeueV2Inst {
    /// Returns the 'components' Output of this 'QueueDequeueV2' operation.
    pub fn components(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'handle' Input of this 'QueueDequeueV2' operation.
    pub fn handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<QueueDequeueV2Inst> for crate::Operation {
    fn from(inst: QueueDequeueV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `QueueDequeueV2::new().build(handle, scope)`.
pub fn queue_dequeue_v2<O0: ::std::convert::Into<crate::Output>>(
    handle: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    QueueDequeueV2::new().build(handle, scope)
}

/// Builder for the `QueueEnqueue` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct QueueEnqueue {
    Tcomponents: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    timeout_ms: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'QueueEnqueue' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct QueueEnqueueInst {
    /// An instance of a fully built QueueEnqueue Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl QueueEnqueue {
    /// Creates a new `QueueEnqueue`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `Tcomponents` attribute.
    pub fn Tcomponents<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tcomponents = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `timeout_ms` attribute.
    pub fn timeout_ms<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.timeout_ms = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `QueueEnqueue` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        handle: O0,
        components: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(handle.into(), components.into(), scope)
    }
    fn build_impl(
        &self,
        handle: crate::Output,
        components: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("QueueEnqueue", |nd| {
            nd.add_input(handle);
            nd.add_input(components);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.Tcomponents {
                nd.set_attr_type_list("Tcomponents", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.timeout_ms {
                nd.set_attr_int("timeout_ms", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'QueueEnqueue' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        handle: crate::Output,
        components: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<QueueEnqueueInst> {
        let op = scope.new_operation("QueueEnqueue", |builder| {
            builder.add_input(handle);
            builder.add_input(components);
            if let ::std::option::Option::Some(value) = &self.Tcomponents {
                builder.set_attr_type_list("Tcomponents", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.timeout_ms {
                builder.set_attr_int("timeout_ms", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(QueueEnqueueInst { op })
    }
}
impl QueueEnqueueInst {
    /// Returns the 'handle' Input of this 'QueueEnqueue' operation.
    pub fn handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'components' Input of this 'QueueEnqueue' operation.
    pub fn components(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<QueueEnqueueInst> for crate::Operation {
    fn from(inst: QueueEnqueueInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `QueueEnqueue::new().build(handle, components, scope)`.
pub fn queue_enqueue<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    handle: O0,
    components: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    QueueEnqueue::new().build(handle, components, scope)
}

/// Builder for the `QueueEnqueueMany` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct QueueEnqueueMany {
    Tcomponents: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    timeout_ms: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'QueueEnqueueMany' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct QueueEnqueueManyInst {
    /// An instance of a fully built QueueEnqueueMany Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl QueueEnqueueMany {
    /// Creates a new `QueueEnqueueMany`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `Tcomponents` attribute.
    pub fn Tcomponents<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tcomponents = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `timeout_ms` attribute.
    pub fn timeout_ms<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.timeout_ms = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `QueueEnqueueMany` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        handle: O0,
        components: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(handle.into(), components.into(), scope)
    }
    fn build_impl(
        &self,
        handle: crate::Output,
        components: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("QueueEnqueueMany", |nd| {
            nd.add_input(handle);
            nd.add_input(components);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.Tcomponents {
                nd.set_attr_type_list("Tcomponents", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.timeout_ms {
                nd.set_attr_int("timeout_ms", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'QueueEnqueueMany' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        handle: crate::Output,
        components: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<QueueEnqueueManyInst> {
        let op = scope.new_operation("QueueEnqueueMany", |builder| {
            builder.add_input(handle);
            builder.add_input(components);
            if let ::std::option::Option::Some(value) = &self.Tcomponents {
                builder.set_attr_type_list("Tcomponents", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.timeout_ms {
                builder.set_attr_int("timeout_ms", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(QueueEnqueueManyInst { op })
    }
}
impl QueueEnqueueManyInst {
    /// Returns the 'handle' Input of this 'QueueEnqueueMany' operation.
    pub fn handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'components' Input of this 'QueueEnqueueMany' operation.
    pub fn components(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<QueueEnqueueManyInst> for crate::Operation {
    fn from(inst: QueueEnqueueManyInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `QueueEnqueueMany::new().build(handle, components, scope)`.
pub fn queue_enqueue_many<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    handle: O0,
    components: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    QueueEnqueueMany::new().build(handle, components, scope)
}

/// Builder for the `QueueEnqueueManyV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct QueueEnqueueManyV2 {
    Tcomponents: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    timeout_ms: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'QueueEnqueueManyV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct QueueEnqueueManyV2Inst {
    /// An instance of a fully built QueueEnqueueManyV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl QueueEnqueueManyV2 {
    /// Creates a new `QueueEnqueueManyV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `Tcomponents` attribute.
    pub fn Tcomponents<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tcomponents = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `timeout_ms` attribute.
    pub fn timeout_ms<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.timeout_ms = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `QueueEnqueueManyV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        handle: O0,
        components: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(handle.into(), components.into(), scope)
    }
    fn build_impl(
        &self,
        handle: crate::Output,
        components: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("QueueEnqueueManyV2", |nd| {
            nd.add_input(handle);
            nd.add_input(components);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.Tcomponents {
                nd.set_attr_type_list("Tcomponents", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.timeout_ms {
                nd.set_attr_int("timeout_ms", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'QueueEnqueueManyV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        handle: crate::Output,
        components: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<QueueEnqueueManyV2Inst> {
        let op = scope.new_operation("QueueEnqueueManyV2", |builder| {
            builder.add_input(handle);
            builder.add_input(components);
            if let ::std::option::Option::Some(value) = &self.Tcomponents {
                builder.set_attr_type_list("Tcomponents", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.timeout_ms {
                builder.set_attr_int("timeout_ms", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(QueueEnqueueManyV2Inst { op })
    }
}
impl QueueEnqueueManyV2Inst {
    /// Returns the 'handle' Input of this 'QueueEnqueueManyV2' operation.
    pub fn handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'components' Input of this 'QueueEnqueueManyV2' operation.
    pub fn components(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<QueueEnqueueManyV2Inst> for crate::Operation {
    fn from(inst: QueueEnqueueManyV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `QueueEnqueueManyV2::new().build(handle, components, scope)`.
pub fn queue_enqueue_many_v2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    handle: O0,
    components: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    QueueEnqueueManyV2::new().build(handle, components, scope)
}

/// Builder for the `QueueEnqueueV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct QueueEnqueueV2 {
    Tcomponents: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    timeout_ms: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'QueueEnqueueV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct QueueEnqueueV2Inst {
    /// An instance of a fully built QueueEnqueueV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl QueueEnqueueV2 {
    /// Creates a new `QueueEnqueueV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `Tcomponents` attribute.
    pub fn Tcomponents<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tcomponents = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `timeout_ms` attribute.
    pub fn timeout_ms<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.timeout_ms = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `QueueEnqueueV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        handle: O0,
        components: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(handle.into(), components.into(), scope)
    }
    fn build_impl(
        &self,
        handle: crate::Output,
        components: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("QueueEnqueueV2", |nd| {
            nd.add_input(handle);
            nd.add_input(components);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.Tcomponents {
                nd.set_attr_type_list("Tcomponents", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.timeout_ms {
                nd.set_attr_int("timeout_ms", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'QueueEnqueueV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        handle: crate::Output,
        components: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<QueueEnqueueV2Inst> {
        let op = scope.new_operation("QueueEnqueueV2", |builder| {
            builder.add_input(handle);
            builder.add_input(components);
            if let ::std::option::Option::Some(value) = &self.Tcomponents {
                builder.set_attr_type_list("Tcomponents", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.timeout_ms {
                builder.set_attr_int("timeout_ms", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(QueueEnqueueV2Inst { op })
    }
}
impl QueueEnqueueV2Inst {
    /// Returns the 'handle' Input of this 'QueueEnqueueV2' operation.
    pub fn handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'components' Input of this 'QueueEnqueueV2' operation.
    pub fn components(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<QueueEnqueueV2Inst> for crate::Operation {
    fn from(inst: QueueEnqueueV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `QueueEnqueueV2::new().build(handle, components, scope)`.
pub fn queue_enqueue_v2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    handle: O0,
    components: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    QueueEnqueueV2::new().build(handle, components, scope)
}

/// Builder for the `QueueIsClosed` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct QueueIsClosed {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'QueueIsClosed' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct QueueIsClosedInst {
    /// An instance of a fully built QueueIsClosed Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl QueueIsClosed {
    /// Creates a new `QueueIsClosed`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `QueueIsClosed` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        handle: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(handle.into(), scope)
    }
    fn build_impl(
        &self,
        handle: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("QueueIsClosed", |nd| {
            nd.add_input(handle);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'QueueIsClosed' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        handle: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<QueueIsClosedInst> {
        let op = scope.new_operation("QueueIsClosed", |builder| {
            builder.add_input(handle);
            ::std::result::Result::Ok(())
        })?;
        Ok(QueueIsClosedInst { op })
    }
}
impl QueueIsClosedInst {
    /// Returns the 'is_closed' Output of this 'QueueIsClosed' operation.
    pub fn is_closed(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'handle' Input of this 'QueueIsClosed' operation.
    pub fn handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<QueueIsClosedInst> for crate::Operation {
    fn from(inst: QueueIsClosedInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `QueueIsClosed::new().build(handle, scope)`.
pub fn queue_is_closed<O0: ::std::convert::Into<crate::Output>>(
    handle: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    QueueIsClosed::new().build(handle, scope)
}

/// Builder for the `QueueIsClosedV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct QueueIsClosedV2 {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'QueueIsClosedV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct QueueIsClosedV2Inst {
    /// An instance of a fully built QueueIsClosedV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl QueueIsClosedV2 {
    /// Creates a new `QueueIsClosedV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `QueueIsClosedV2` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        handle: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(handle.into(), scope)
    }
    fn build_impl(
        &self,
        handle: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("QueueIsClosedV2", |nd| {
            nd.add_input(handle);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'QueueIsClosedV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        handle: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<QueueIsClosedV2Inst> {
        let op = scope.new_operation("QueueIsClosedV2", |builder| {
            builder.add_input(handle);
            ::std::result::Result::Ok(())
        })?;
        Ok(QueueIsClosedV2Inst { op })
    }
}
impl QueueIsClosedV2Inst {
    /// Returns the 'is_closed' Output of this 'QueueIsClosedV2' operation.
    pub fn is_closed(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'handle' Input of this 'QueueIsClosedV2' operation.
    pub fn handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<QueueIsClosedV2Inst> for crate::Operation {
    fn from(inst: QueueIsClosedV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `QueueIsClosedV2::new().build(handle, scope)`.
pub fn queue_is_closed_v2<O0: ::std::convert::Into<crate::Output>>(
    handle: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    QueueIsClosedV2::new().build(handle, scope)
}

/// Builder for the `QueueSize` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct QueueSize {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'QueueSize' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct QueueSizeInst {
    /// An instance of a fully built QueueSize Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl QueueSize {
    /// Creates a new `QueueSize`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `QueueSize` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        handle: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(handle.into(), scope)
    }
    fn build_impl(
        &self,
        handle: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("QueueSize", |nd| {
            nd.add_input(handle);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'QueueSize' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        handle: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<QueueSizeInst> {
        let op = scope.new_operation("QueueSize", |builder| {
            builder.add_input(handle);
            ::std::result::Result::Ok(())
        })?;
        Ok(QueueSizeInst { op })
    }
}
impl QueueSizeInst {
    /// Returns the 'size' Output of this 'QueueSize' operation.
    pub fn size(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'handle' Input of this 'QueueSize' operation.
    pub fn handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<QueueSizeInst> for crate::Operation {
    fn from(inst: QueueSizeInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `QueueSize::new().build(handle, scope)`.
pub fn queue_size<O0: ::std::convert::Into<crate::Output>>(
    handle: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    QueueSize::new().build(handle, scope)
}

/// Builder for the `QueueSizeV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct QueueSizeV2 {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'QueueSizeV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct QueueSizeV2Inst {
    /// An instance of a fully built QueueSizeV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl QueueSizeV2 {
    /// Creates a new `QueueSizeV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `QueueSizeV2` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        handle: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(handle.into(), scope)
    }
    fn build_impl(
        &self,
        handle: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("QueueSizeV2", |nd| {
            nd.add_input(handle);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'QueueSizeV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        handle: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<QueueSizeV2Inst> {
        let op = scope.new_operation("QueueSizeV2", |builder| {
            builder.add_input(handle);
            ::std::result::Result::Ok(())
        })?;
        Ok(QueueSizeV2Inst { op })
    }
}
impl QueueSizeV2Inst {
    /// Returns the 'size' Output of this 'QueueSizeV2' operation.
    pub fn size(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'handle' Input of this 'QueueSizeV2' operation.
    pub fn handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<QueueSizeV2Inst> for crate::Operation {
    fn from(inst: QueueSizeV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `QueueSizeV2::new().build(handle, scope)`.
pub fn queue_size_v2<O0: ::std::convert::Into<crate::Output>>(
    handle: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    QueueSizeV2::new().build(handle, scope)
}

/// Builder for the `RFFT` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RFFT {
    Treal: ::std::option::Option<crate::DataType>,
    Tcomplex: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RFFT' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RFFTInst {
    /// An instance of a fully built RFFT Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RFFT {
    /// Creates a new `RFFT`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `Treal` attribute.
    pub fn Treal<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Treal = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tcomplex` attribute.
    pub fn Tcomplex<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tcomplex = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RFFT` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        fft_length: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), fft_length.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        fft_length: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("RFFT", |nd| {
            nd.add_input(input);
            nd.add_input(fft_length);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.Treal {
                nd.set_attr_type("Treal", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tcomplex {
                nd.set_attr_type("Tcomplex", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RFFT' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        fft_length: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<RFFTInst> {
        let op = scope.new_operation("RFFT", |builder| {
            builder.add_input(input);
            builder.add_input(fft_length);
            if let ::std::option::Option::Some(value) = &self.Treal {
                builder.set_attr_type("Treal", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tcomplex {
                builder.set_attr_type("Tcomplex", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RFFTInst { op })
    }
}
impl RFFTInst {
    /// Returns the 'output' Output of this 'RFFT' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'RFFT' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'fft_length' Input of this 'RFFT' operation.
    pub fn fft_length(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<RFFTInst> for crate::Operation {
    fn from(inst: RFFTInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RFFT::new().build(input, fft_length, scope)`.
pub fn rfft<O0: ::std::convert::Into<crate::Output>, O1: ::std::convert::Into<crate::Output>>(
    input: O0,
    fft_length: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RFFT::new().build(input, fft_length, scope)
}

/// Builder for the `RFFT2D` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RFFT2D {
    Treal: ::std::option::Option<crate::DataType>,
    Tcomplex: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RFFT2D' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RFFT2DInst {
    /// An instance of a fully built RFFT2D Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RFFT2D {
    /// Creates a new `RFFT2D`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `Treal` attribute.
    pub fn Treal<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Treal = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tcomplex` attribute.
    pub fn Tcomplex<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tcomplex = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RFFT2D` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        fft_length: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), fft_length.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        fft_length: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("RFFT2D", |nd| {
            nd.add_input(input);
            nd.add_input(fft_length);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.Treal {
                nd.set_attr_type("Treal", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tcomplex {
                nd.set_attr_type("Tcomplex", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RFFT2D' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        fft_length: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<RFFT2DInst> {
        let op = scope.new_operation("RFFT2D", |builder| {
            builder.add_input(input);
            builder.add_input(fft_length);
            if let ::std::option::Option::Some(value) = &self.Treal {
                builder.set_attr_type("Treal", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tcomplex {
                builder.set_attr_type("Tcomplex", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RFFT2DInst { op })
    }
}
impl RFFT2DInst {
    /// Returns the 'output' Output of this 'RFFT2D' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'RFFT2D' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'fft_length' Input of this 'RFFT2D' operation.
    pub fn fft_length(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<RFFT2DInst> for crate::Operation {
    fn from(inst: RFFT2DInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RFFT2D::new().build(input, fft_length, scope)`.
pub fn rfft2_d<O0: ::std::convert::Into<crate::Output>, O1: ::std::convert::Into<crate::Output>>(
    input: O0,
    fft_length: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RFFT2D::new().build(input, fft_length, scope)
}

/// Builder for the `RFFT3D` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RFFT3D {
    Treal: ::std::option::Option<crate::DataType>,
    Tcomplex: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RFFT3D' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RFFT3DInst {
    /// An instance of a fully built RFFT3D Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RFFT3D {
    /// Creates a new `RFFT3D`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `Treal` attribute.
    pub fn Treal<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Treal = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tcomplex` attribute.
    pub fn Tcomplex<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tcomplex = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RFFT3D` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        fft_length: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), fft_length.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        fft_length: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("RFFT3D", |nd| {
            nd.add_input(input);
            nd.add_input(fft_length);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.Treal {
                nd.set_attr_type("Treal", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tcomplex {
                nd.set_attr_type("Tcomplex", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RFFT3D' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        fft_length: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<RFFT3DInst> {
        let op = scope.new_operation("RFFT3D", |builder| {
            builder.add_input(input);
            builder.add_input(fft_length);
            if let ::std::option::Option::Some(value) = &self.Treal {
                builder.set_attr_type("Treal", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tcomplex {
                builder.set_attr_type("Tcomplex", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RFFT3DInst { op })
    }
}
impl RFFT3DInst {
    /// Returns the 'output' Output of this 'RFFT3D' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'RFFT3D' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'fft_length' Input of this 'RFFT3D' operation.
    pub fn fft_length(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<RFFT3DInst> for crate::Operation {
    fn from(inst: RFFT3DInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RFFT3D::new().build(input, fft_length, scope)`.
pub fn rfft3_d<O0: ::std::convert::Into<crate::Output>, O1: ::std::convert::Into<crate::Output>>(
    input: O0,
    fft_length: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RFFT3D::new().build(input, fft_length, scope)
}

/// Builder for the `RGBToHSV` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RGBToHSV {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RGBToHSV' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RGBToHSVInst {
    /// An instance of a fully built RGBToHSV Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RGBToHSV {
    /// Creates a new `RGBToHSV`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RGBToHSV` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        images: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(images.into(), scope)
    }
    fn build_impl(
        &self,
        images: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("RGBToHSV", |nd| {
            nd.add_input(images);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RGBToHSV' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        images: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<RGBToHSVInst> {
        let op = scope.new_operation("RGBToHSV", |builder| {
            builder.add_input(images);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RGBToHSVInst { op })
    }
}
impl RGBToHSVInst {
    /// Returns the 'output' Output of this 'RGBToHSV' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'images' Input of this 'RGBToHSV' operation.
    pub fn images(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<RGBToHSVInst> for crate::Operation {
    fn from(inst: RGBToHSVInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RGBToHSV::new().build(images, scope)`.
pub fn rgbto_hsv<O0: ::std::convert::Into<crate::Output>>(
    images: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RGBToHSV::new().build(images, scope)
}

/// Builder for the `RaggedBincount` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RaggedBincount {
    Tidx: ::std::option::Option<crate::DataType>,
    T: ::std::option::Option<crate::DataType>,
    binary_output: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RaggedBincount' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RaggedBincountInst {
    /// An instance of a fully built RaggedBincount Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RaggedBincount {
    /// Creates a new `RaggedBincount`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `Tidx` attribute.
    pub fn Tidx<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Tidx = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `binary_output` attribute.
    pub fn binary_output<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.binary_output = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RaggedBincount` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
    >(
        &self,
        splits: O0,
        values: O1,
        size: O2,
        weights: O3,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            splits.into(),
            values.into(),
            size.into(),
            weights.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        splits: crate::Output,
        values: crate::Output,
        size: crate::Output,
        weights: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("RaggedBincount", |nd| {
            nd.add_input(splits);
            nd.add_input(values);
            nd.add_input(size);
            nd.add_input(weights);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.Tidx {
                nd.set_attr_type("Tidx", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.binary_output {
                nd.set_attr_bool("binary_output", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RaggedBincount' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        splits: crate::Output,
        values: crate::Output,
        size: crate::Output,
        weights: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<RaggedBincountInst> {
        let op = scope.new_operation("RaggedBincount", |builder| {
            builder.add_input(splits);
            builder.add_input(values);
            builder.add_input(size);
            builder.add_input(weights);
            if let ::std::option::Option::Some(value) = &self.Tidx {
                builder.set_attr_type("Tidx", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.binary_output {
                builder.set_attr_bool("binary_output", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RaggedBincountInst { op })
    }
}
impl RaggedBincountInst {
    /// Returns the 'output' Output of this 'RaggedBincount' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'splits' Input of this 'RaggedBincount' operation.
    pub fn splits(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'values' Input of this 'RaggedBincount' operation.
    pub fn values(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'size' Input of this 'RaggedBincount' operation.
    pub fn size(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'weights' Input of this 'RaggedBincount' operation.
    pub fn weights(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
}
impl From<RaggedBincountInst> for crate::Operation {
    fn from(inst: RaggedBincountInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RaggedBincount::new().build(splits, values, size, weights, scope)`.
pub fn ragged_bincount<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
>(
    splits: O0,
    values: O1,
    size: O2,
    weights: O3,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RaggedBincount::new().build(splits, values, size, weights, scope)
}

/// Builder for the `RaggedCountSparseOutput` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RaggedCountSparseOutput {
    T: ::std::option::Option<crate::DataType>,
    minlength: ::std::option::Option<i64>,
    maxlength: ::std::option::Option<i64>,
    binary_output: ::std::option::Option<bool>,
    output_type: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RaggedCountSparseOutput' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RaggedCountSparseOutputInst {
    /// An instance of a fully built RaggedCountSparseOutput Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RaggedCountSparseOutput {
    /// Creates a new `RaggedCountSparseOutput`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `minlength` attribute.
    pub fn minlength<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.minlength = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `maxlength` attribute.
    pub fn maxlength<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.maxlength = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `binary_output` attribute.
    pub fn binary_output<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.binary_output = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_type` attribute.
    pub fn output_type<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_type = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RaggedCountSparseOutput` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        splits: O0,
        values: O1,
        weights: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(splits.into(), values.into(), weights.into(), scope)
    }
    fn build_impl(
        &self,
        splits: crate::Output,
        values: crate::Output,
        weights: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("RaggedCountSparseOutput", |nd| {
            nd.add_input(splits);
            nd.add_input(values);
            nd.add_input(weights);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.minlength {
                nd.set_attr_int("minlength", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.maxlength {
                nd.set_attr_int("maxlength", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.binary_output {
                nd.set_attr_bool("binary_output", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_type {
                nd.set_attr_type("output_type", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RaggedCountSparseOutput' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        splits: crate::Output,
        values: crate::Output,
        weights: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<RaggedCountSparseOutputInst> {
        let op = scope.new_operation("RaggedCountSparseOutput", |builder| {
            builder.add_input(splits);
            builder.add_input(values);
            builder.add_input(weights);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.minlength {
                builder.set_attr_int("minlength", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.maxlength {
                builder.set_attr_int("maxlength", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.binary_output {
                builder.set_attr_bool("binary_output", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_type {
                builder.set_attr_type("output_type", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RaggedCountSparseOutputInst { op })
    }
}
impl RaggedCountSparseOutputInst {
    /// Returns the 'output_indices' Output of this 'RaggedCountSparseOutput' operation.
    pub fn output_indices(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'output_values' Output of this 'RaggedCountSparseOutput' operation.
    pub fn output_values(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'output_dense_shape' Output of this 'RaggedCountSparseOutput' operation.
    pub fn output_dense_shape(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns the 'splits' Input of this 'RaggedCountSparseOutput' operation.
    pub fn splits(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'values' Input of this 'RaggedCountSparseOutput' operation.
    pub fn values(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'weights' Input of this 'RaggedCountSparseOutput' operation.
    pub fn weights(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<RaggedCountSparseOutputInst> for crate::Operation {
    fn from(inst: RaggedCountSparseOutputInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RaggedCountSparseOutput::new().build(splits, values, weights, scope)`.
pub fn ragged_count_sparse_output<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    splits: O0,
    values: O1,
    weights: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RaggedCountSparseOutput::new().build(splits, values, weights, scope)
}

/// Builder for the `RaggedCross` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RaggedCross {
    Nsparse: ::std::option::Option<i64>,
    input_order: ::std::option::Option<::std::string::String>,
    hashed_output: ::std::option::Option<bool>,
    num_buckets: ::std::option::Option<i64>,
    hash_key: ::std::option::Option<i64>,
    ragged_values_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    ragged_splits_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    sparse_values_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    dense_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    out_values_type: ::std::option::Option<crate::DataType>,
    out_row_splits_type: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RaggedCross' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RaggedCrossInst {
    /// An instance of a fully built RaggedCross Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RaggedCross {
    /// Creates a new `RaggedCross`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `Nsparse` attribute.
    pub fn Nsparse<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.Nsparse = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `input_order` attribute.
    pub fn input_order<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.input_order = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `hashed_output` attribute.
    pub fn hashed_output<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.hashed_output = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `num_buckets` attribute.
    pub fn num_buckets<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.num_buckets = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `hash_key` attribute.
    pub fn hash_key<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.hash_key = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `ragged_values_types` attribute.
    pub fn ragged_values_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.ragged_values_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `ragged_splits_types` attribute.
    pub fn ragged_splits_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.ragged_splits_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `sparse_values_types` attribute.
    pub fn sparse_values_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.sparse_values_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `dense_types` attribute.
    pub fn dense_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.dense_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `out_values_type` attribute.
    pub fn out_values_type<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.out_values_type = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `out_row_splits_type` attribute.
    pub fn out_row_splits_type<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.out_row_splits_type = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RaggedCross` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
    >(
        &self,
        ragged_values: O0,
        ragged_row_splits: O1,
        sparse_indices: O2,
        sparse_values: O3,
        sparse_shape: O4,
        dense_inputs: O5,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            ragged_values.into(),
            ragged_row_splits.into(),
            sparse_indices.into(),
            sparse_values.into(),
            sparse_shape.into(),
            dense_inputs.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        ragged_values: crate::Output,
        ragged_row_splits: crate::Output,
        sparse_indices: crate::Output,
        sparse_values: crate::Output,
        sparse_shape: crate::Output,
        dense_inputs: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("RaggedCross", |nd| {
            nd.add_input(ragged_values);
            nd.add_input(ragged_row_splits);
            nd.add_input(sparse_indices);
            nd.add_input(sparse_values);
            nd.add_input(sparse_shape);
            nd.add_input(dense_inputs);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.Nsparse {
                nd.set_attr_int("Nsparse", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.input_order {
                nd.set_attr_string("input_order", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.hashed_output {
                nd.set_attr_bool("hashed_output", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_buckets {
                nd.set_attr_int("num_buckets", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.hash_key {
                nd.set_attr_int("hash_key", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.ragged_values_types {
                nd.set_attr_type_list("ragged_values_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.ragged_splits_types {
                nd.set_attr_type_list("ragged_splits_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.sparse_values_types {
                nd.set_attr_type_list("sparse_values_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dense_types {
                nd.set_attr_type_list("dense_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.out_values_type {
                nd.set_attr_type("out_values_type", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.out_row_splits_type {
                nd.set_attr_type("out_row_splits_type", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RaggedCross' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        ragged_values: crate::Output,
        ragged_row_splits: crate::Output,
        sparse_indices: Vec<crate::Output>,
        sparse_values: crate::Output,
        sparse_shape: Vec<crate::Output>,
        dense_inputs: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<RaggedCrossInst> {
        let op = scope.new_operation("RaggedCross", |builder| {
            builder.add_input(ragged_values);
            builder.add_input(ragged_row_splits);
            builder.add_input_list(&sparse_indices);
            builder.add_input(sparse_values);
            builder.add_input_list(&sparse_shape);
            builder.add_input(dense_inputs);
            builder.set_attr_int("Nsparse", sparse_indices.clone().len() as i64)?;
            if let ::std::option::Option::Some(value) = &self.input_order {
                builder.set_attr_string("input_order", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.hashed_output {
                builder.set_attr_bool("hashed_output", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_buckets {
                builder.set_attr_int("num_buckets", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.hash_key {
                builder.set_attr_int("hash_key", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.ragged_values_types {
                builder.set_attr_type_list("ragged_values_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.ragged_splits_types {
                builder.set_attr_type_list("ragged_splits_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.sparse_values_types {
                builder.set_attr_type_list("sparse_values_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dense_types {
                builder.set_attr_type_list("dense_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.out_values_type {
                builder.set_attr_type("out_values_type", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.out_row_splits_type {
                builder.set_attr_type("out_row_splits_type", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RaggedCrossInst { op })
    }
}
impl RaggedCrossInst {
    /// Returns the 'output_values' Output of this 'RaggedCross' operation.
    pub fn output_values(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'output_row_splits' Output of this 'RaggedCross' operation.
    pub fn output_row_splits(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'ragged_values' Input of this 'RaggedCross' operation.
    pub fn ragged_values(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'ragged_row_splits' Input of this 'RaggedCross' operation.
    pub fn ragged_row_splits(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns a Vector of sparse_indices for 'sparse_indices' Input of this RaggedCross operation.
    pub fn sparse_indices(&self) -> crate::Result<Vec<crate::Input>> {
        let mut Inputs = vec![];
        for i in 2..self.op.get_attr_int("Nsparse")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
    /// Returns the 'sparse_values' Input of this 'RaggedCross' operation.
    pub fn sparse_values(&self) -> crate::Result<crate::Input> {
        let dynamic_offset = (self.op.get_attr_int("Nsparse")? + 3) as i32;
        Ok(crate::Input {
            operation: &self.op,
            index: dynamic_offset,
        })
    }
    /// Returns a Vector of sparse_shape for 'sparse_shape' Input of this RaggedCross operation.
    pub fn sparse_shape(&self) -> crate::Result<Vec<crate::Input>> {
        let dynamic_offset = (self.op.get_attr_int("Nsparse")? + 4) as i32;
        let mut Inputs = vec![];
        for i in dynamic_offset..dynamic_offset + self.op.get_attr_int("Nsparse")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
    /// Returns the 'dense_inputs' Input of this 'RaggedCross' operation.
    pub fn dense_inputs(&self) -> crate::Result<crate::Input> {
        let dynamic_offset = (2 * self.op.get_attr_int("Nsparse")? + 5) as i32;
        Ok(crate::Input {
            operation: &self.op,
            index: dynamic_offset,
        })
    }
}
impl From<RaggedCrossInst> for crate::Operation {
    fn from(inst: RaggedCrossInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RaggedCross::new().build(ragged_values, ragged_row_splits, sparse_indices, sparse_values, sparse_shape, dense_inputs, scope)`.
pub fn ragged_cross<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
>(
    ragged_values: O0,
    ragged_row_splits: O1,
    sparse_indices: O2,
    sparse_values: O3,
    sparse_shape: O4,
    dense_inputs: O5,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RaggedCross::new().build(
        ragged_values,
        ragged_row_splits,
        sparse_indices,
        sparse_values,
        sparse_shape,
        dense_inputs,
        scope,
    )
}

/// Builder for the `RaggedFillEmptyRows` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RaggedFillEmptyRows {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RaggedFillEmptyRows' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RaggedFillEmptyRowsInst {
    /// An instance of a fully built RaggedFillEmptyRows Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RaggedFillEmptyRows {
    /// Creates a new `RaggedFillEmptyRows`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RaggedFillEmptyRows` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
    >(
        &self,
        value_rowids: O0,
        values: O1,
        nrows: O2,
        default_value: O3,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            value_rowids.into(),
            values.into(),
            nrows.into(),
            default_value.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        value_rowids: crate::Output,
        values: crate::Output,
        nrows: crate::Output,
        default_value: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("RaggedFillEmptyRows", |nd| {
            nd.add_input(value_rowids);
            nd.add_input(values);
            nd.add_input(nrows);
            nd.add_input(default_value);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RaggedFillEmptyRows' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        value_rowids: crate::Output,
        values: crate::Output,
        nrows: crate::Output,
        default_value: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<RaggedFillEmptyRowsInst> {
        let op = scope.new_operation("RaggedFillEmptyRows", |builder| {
            builder.add_input(value_rowids);
            builder.add_input(values);
            builder.add_input(nrows);
            builder.add_input(default_value);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RaggedFillEmptyRowsInst { op })
    }
}
impl RaggedFillEmptyRowsInst {
    /// Returns the 'output_value_rowids' Output of this 'RaggedFillEmptyRows' operation.
    pub fn output_value_rowids(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'output_values' Output of this 'RaggedFillEmptyRows' operation.
    pub fn output_values(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'empty_row_indicator' Output of this 'RaggedFillEmptyRows' operation.
    pub fn empty_row_indicator(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns the 'reverse_index_map' Output of this 'RaggedFillEmptyRows' operation.
    pub fn reverse_index_map(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 3,
        }
    }
    /// Returns the 'value_rowids' Input of this 'RaggedFillEmptyRows' operation.
    pub fn value_rowids(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'values' Input of this 'RaggedFillEmptyRows' operation.
    pub fn values(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'nrows' Input of this 'RaggedFillEmptyRows' operation.
    pub fn nrows(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'default_value' Input of this 'RaggedFillEmptyRows' operation.
    pub fn default_value(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
}
impl From<RaggedFillEmptyRowsInst> for crate::Operation {
    fn from(inst: RaggedFillEmptyRowsInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RaggedFillEmptyRows::new().build(value_rowids, values, nrows, default_value, scope)`.
pub fn ragged_fill_empty_rows<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
>(
    value_rowids: O0,
    values: O1,
    nrows: O2,
    default_value: O3,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RaggedFillEmptyRows::new().build(value_rowids, values, nrows, default_value, scope)
}

/// Builder for the `RaggedFillEmptyRowsGrad` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RaggedFillEmptyRowsGrad {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RaggedFillEmptyRowsGrad' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RaggedFillEmptyRowsGradInst {
    /// An instance of a fully built RaggedFillEmptyRowsGrad Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RaggedFillEmptyRowsGrad {
    /// Creates a new `RaggedFillEmptyRowsGrad`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RaggedFillEmptyRowsGrad` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        reverse_index_map: O0,
        grad_values: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(reverse_index_map.into(), grad_values.into(), scope)
    }
    fn build_impl(
        &self,
        reverse_index_map: crate::Output,
        grad_values: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("RaggedFillEmptyRowsGrad", |nd| {
            nd.add_input(reverse_index_map);
            nd.add_input(grad_values);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RaggedFillEmptyRowsGrad' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        reverse_index_map: crate::Output,
        grad_values: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<RaggedFillEmptyRowsGradInst> {
        let op = scope.new_operation("RaggedFillEmptyRowsGrad", |builder| {
            builder.add_input(reverse_index_map);
            builder.add_input(grad_values);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RaggedFillEmptyRowsGradInst { op })
    }
}
impl RaggedFillEmptyRowsGradInst {
    /// Returns the 'd_values' Output of this 'RaggedFillEmptyRowsGrad' operation.
    pub fn d_values(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'd_default_value' Output of this 'RaggedFillEmptyRowsGrad' operation.
    pub fn d_default_value(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'reverse_index_map' Input of this 'RaggedFillEmptyRowsGrad' operation.
    pub fn reverse_index_map(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'grad_values' Input of this 'RaggedFillEmptyRowsGrad' operation.
    pub fn grad_values(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<RaggedFillEmptyRowsGradInst> for crate::Operation {
    fn from(inst: RaggedFillEmptyRowsGradInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RaggedFillEmptyRowsGrad::new().build(reverse_index_map, grad_values, scope)`.
pub fn ragged_fill_empty_rows_grad<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    reverse_index_map: O0,
    grad_values: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RaggedFillEmptyRowsGrad::new().build(reverse_index_map, grad_values, scope)
}

/// Builder for the `RaggedGather` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RaggedGather {
    Tvalues: ::std::option::Option<crate::DataType>,
    Tindices: ::std::option::Option<crate::DataType>,
    Tsplits: ::std::option::Option<crate::DataType>,
    PARAMS_RAGGED_RANK: ::std::option::Option<i64>,
    OUTPUT_RAGGED_RANK: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RaggedGather' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RaggedGatherInst {
    /// An instance of a fully built RaggedGather Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RaggedGather {
    /// Creates a new `RaggedGather`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `Tvalues` attribute.
    pub fn Tvalues<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tvalues = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tindices` attribute.
    pub fn Tindices<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tindices = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tsplits` attribute.
    pub fn Tsplits<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tsplits = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `PARAMS_RAGGED_RANK` attribute.
    pub fn PARAMS_RAGGED_RANK<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.PARAMS_RAGGED_RANK = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `OUTPUT_RAGGED_RANK` attribute.
    pub fn OUTPUT_RAGGED_RANK<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.OUTPUT_RAGGED_RANK = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RaggedGather` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        params_nested_splits: O0,
        params_dense_values: O1,
        indices: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            params_nested_splits.into(),
            params_dense_values.into(),
            indices.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        params_nested_splits: crate::Output,
        params_dense_values: crate::Output,
        indices: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("RaggedGather", |nd| {
            nd.add_input(params_nested_splits);
            nd.add_input(params_dense_values);
            nd.add_input(indices);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.Tvalues {
                nd.set_attr_type("Tvalues", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                nd.set_attr_type("Tindices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tsplits {
                nd.set_attr_type("Tsplits", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.PARAMS_RAGGED_RANK {
                nd.set_attr_int("PARAMS_RAGGED_RANK", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.OUTPUT_RAGGED_RANK {
                nd.set_attr_int("OUTPUT_RAGGED_RANK", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RaggedGather' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        params_nested_splits: Vec<crate::Output>,
        params_dense_values: crate::Output,
        indices: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<RaggedGatherInst> {
        let op = scope.new_operation("RaggedGather", |builder| {
            builder.add_input_list(&params_nested_splits);
            builder.add_input(params_dense_values);
            builder.add_input(indices);
            if let ::std::option::Option::Some(value) = &self.Tvalues {
                builder.set_attr_type("Tvalues", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                builder.set_attr_type("Tindices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tsplits {
                builder.set_attr_type("Tsplits", *value)?;
            }
            builder.set_attr_int(
                "PARAMS_RAGGED_RANK",
                params_nested_splits.clone().len() as i64,
            )?;
            if let ::std::option::Option::Some(value) = &self.OUTPUT_RAGGED_RANK {
                builder.set_attr_int("OUTPUT_RAGGED_RANK", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RaggedGatherInst { op })
    }
}
impl RaggedGatherInst {
    /// Returns a Vector of output_nested_splits for 'output_nested_splits' Output of this RaggedGather operation.
    pub fn output_nested_splits(&self) -> crate::Result<Vec<crate::Output>> {
        let mut Outputs = vec![];
        for i in 0..self.op.get_attr_int("OUTPUT_RAGGED_RANK")? as i32 {
            Outputs.push(crate::Output {
                operation: self.op.clone(),
                index: i,
            });
        }
        Ok(Outputs)
    }
    /// Returns the 'output_dense_values' Output of this 'RaggedGather' operation.
    pub fn output_dense_values(&self) -> crate::Result<crate::Output> {
        let dynamic_offset = (self.op.get_attr_int("OUTPUT_RAGGED_RANK")? + 1) as i32;
        Ok(crate::Output {
            operation: self.op.clone(),
            index: dynamic_offset,
        })
    }
    /// Returns a Vector of params_nested_splits for 'params_nested_splits' Input of this RaggedGather operation.
    pub fn params_nested_splits(&self) -> crate::Result<Vec<crate::Input>> {
        let mut Inputs = vec![];
        for i in 0..self.op.get_attr_int("PARAMS_RAGGED_RANK")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
    /// Returns the 'params_dense_values' Input of this 'RaggedGather' operation.
    pub fn params_dense_values(&self) -> crate::Result<crate::Input> {
        let dynamic_offset = (self.op.get_attr_int("PARAMS_RAGGED_RANK")? + 1) as i32;
        Ok(crate::Input {
            operation: &self.op,
            index: dynamic_offset,
        })
    }
    /// Returns the 'indices' Input of this 'RaggedGather' operation.
    pub fn indices(&self) -> crate::Result<crate::Input> {
        let dynamic_offset = (self.op.get_attr_int("PARAMS_RAGGED_RANK")? + 2) as i32;
        Ok(crate::Input {
            operation: &self.op,
            index: dynamic_offset,
        })
    }
}
impl From<RaggedGatherInst> for crate::Operation {
    fn from(inst: RaggedGatherInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RaggedGather::new().build(params_nested_splits, params_dense_values, indices, scope)`.
pub fn ragged_gather<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    params_nested_splits: O0,
    params_dense_values: O1,
    indices: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RaggedGather::new().build(params_nested_splits, params_dense_values, indices, scope)
}

/// Builder for the `RaggedRange` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RaggedRange {
    T: ::std::option::Option<crate::DataType>,
    Tsplits: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RaggedRange' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RaggedRangeInst {
    /// An instance of a fully built RaggedRange Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RaggedRange {
    /// Creates a new `RaggedRange`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tsplits` attribute.
    pub fn Tsplits<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tsplits = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RaggedRange` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        starts: O0,
        limits: O1,
        deltas: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(starts.into(), limits.into(), deltas.into(), scope)
    }
    fn build_impl(
        &self,
        starts: crate::Output,
        limits: crate::Output,
        deltas: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("RaggedRange", |nd| {
            nd.add_input(starts);
            nd.add_input(limits);
            nd.add_input(deltas);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tsplits {
                nd.set_attr_type("Tsplits", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RaggedRange' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        starts: crate::Output,
        limits: crate::Output,
        deltas: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<RaggedRangeInst> {
        let op = scope.new_operation("RaggedRange", |builder| {
            builder.add_input(starts);
            builder.add_input(limits);
            builder.add_input(deltas);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tsplits {
                builder.set_attr_type("Tsplits", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RaggedRangeInst { op })
    }
}
impl RaggedRangeInst {
    /// Returns the 'rt_nested_splits' Output of this 'RaggedRange' operation.
    pub fn rt_nested_splits(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'rt_dense_values' Output of this 'RaggedRange' operation.
    pub fn rt_dense_values(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'starts' Input of this 'RaggedRange' operation.
    pub fn starts(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'limits' Input of this 'RaggedRange' operation.
    pub fn limits(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'deltas' Input of this 'RaggedRange' operation.
    pub fn deltas(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<RaggedRangeInst> for crate::Operation {
    fn from(inst: RaggedRangeInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RaggedRange::new().build(starts, limits, deltas, scope)`.
pub fn ragged_range<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    starts: O0,
    limits: O1,
    deltas: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RaggedRange::new().build(starts, limits, deltas, scope)
}

/// Builder for the `RaggedTensorFromVariant` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RaggedTensorFromVariant {
    input_ragged_rank: ::std::option::Option<i64>,
    output_ragged_rank: ::std::option::Option<i64>,
    Tvalues: ::std::option::Option<crate::DataType>,
    Tsplits: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RaggedTensorFromVariant' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RaggedTensorFromVariantInst {
    /// An instance of a fully built RaggedTensorFromVariant Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RaggedTensorFromVariant {
    /// Creates a new `RaggedTensorFromVariant`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `input_ragged_rank` attribute.
    pub fn input_ragged_rank<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.input_ragged_rank = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_ragged_rank` attribute.
    pub fn output_ragged_rank<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_ragged_rank = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tvalues` attribute.
    pub fn Tvalues<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tvalues = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tsplits` attribute.
    pub fn Tsplits<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tsplits = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RaggedTensorFromVariant` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        encoded_ragged: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(encoded_ragged.into(), scope)
    }
    fn build_impl(
        &self,
        encoded_ragged: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("RaggedTensorFromVariant", |nd| {
            nd.add_input(encoded_ragged);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.input_ragged_rank {
                nd.set_attr_int("input_ragged_rank", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_ragged_rank {
                nd.set_attr_int("output_ragged_rank", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tvalues {
                nd.set_attr_type("Tvalues", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tsplits {
                nd.set_attr_type("Tsplits", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RaggedTensorFromVariant' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        encoded_ragged: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<RaggedTensorFromVariantInst> {
        let op = scope.new_operation("RaggedTensorFromVariant", |builder| {
            builder.add_input(encoded_ragged);
            if let ::std::option::Option::Some(value) = &self.input_ragged_rank {
                builder.set_attr_int("input_ragged_rank", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_ragged_rank {
                builder.set_attr_int("output_ragged_rank", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tvalues {
                builder.set_attr_type("Tvalues", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tsplits {
                builder.set_attr_type("Tsplits", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RaggedTensorFromVariantInst { op })
    }
}
impl RaggedTensorFromVariantInst {
    /// Returns a Vector of output_nested_splits for 'output_nested_splits' Output of this RaggedTensorFromVariant operation.
    pub fn output_nested_splits(&self) -> crate::Result<Vec<crate::Output>> {
        let mut Outputs = vec![];
        for i in 0..self.op.get_attr_int("output_ragged_rank")? as i32 {
            Outputs.push(crate::Output {
                operation: self.op.clone(),
                index: i,
            });
        }
        Ok(Outputs)
    }
    /// Returns the 'output_dense_values' Output of this 'RaggedTensorFromVariant' operation.
    pub fn output_dense_values(&self) -> crate::Result<crate::Output> {
        let dynamic_offset = (self.op.get_attr_int("output_ragged_rank")? + 1) as i32;
        Ok(crate::Output {
            operation: self.op.clone(),
            index: dynamic_offset,
        })
    }
    /// Returns the 'encoded_ragged' Input of this 'RaggedTensorFromVariant' operation.
    pub fn encoded_ragged(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<RaggedTensorFromVariantInst> for crate::Operation {
    fn from(inst: RaggedTensorFromVariantInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RaggedTensorFromVariant::new().build(encoded_ragged, scope)`.
pub fn ragged_tensor_from_variant<O0: ::std::convert::Into<crate::Output>>(
    encoded_ragged: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RaggedTensorFromVariant::new().build(encoded_ragged, scope)
}

/// Builder for the `RaggedTensorToSparse` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RaggedTensorToSparse {
    RAGGED_RANK: ::std::option::Option<i64>,
    T: ::std::option::Option<crate::DataType>,
    Tsplits: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RaggedTensorToSparse' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RaggedTensorToSparseInst {
    /// An instance of a fully built RaggedTensorToSparse Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RaggedTensorToSparse {
    /// Creates a new `RaggedTensorToSparse`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `RAGGED_RANK` attribute.
    pub fn RAGGED_RANK<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.RAGGED_RANK = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tsplits` attribute.
    pub fn Tsplits<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tsplits = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RaggedTensorToSparse` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        rt_nested_splits: O0,
        rt_dense_values: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(rt_nested_splits.into(), rt_dense_values.into(), scope)
    }
    fn build_impl(
        &self,
        rt_nested_splits: crate::Output,
        rt_dense_values: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("RaggedTensorToSparse", |nd| {
            nd.add_input(rt_nested_splits);
            nd.add_input(rt_dense_values);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.RAGGED_RANK {
                nd.set_attr_int("RAGGED_RANK", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tsplits {
                nd.set_attr_type("Tsplits", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RaggedTensorToSparse' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        rt_nested_splits: Vec<crate::Output>,
        rt_dense_values: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<RaggedTensorToSparseInst> {
        let op = scope.new_operation("RaggedTensorToSparse", |builder| {
            builder.add_input_list(&rt_nested_splits);
            builder.add_input(rt_dense_values);
            builder.set_attr_int("RAGGED_RANK", rt_nested_splits.clone().len() as i64)?;
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tsplits {
                builder.set_attr_type("Tsplits", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RaggedTensorToSparseInst { op })
    }
}
impl RaggedTensorToSparseInst {
    /// Returns the 'sparse_indices' Output of this 'RaggedTensorToSparse' operation.
    pub fn sparse_indices(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'sparse_values' Output of this 'RaggedTensorToSparse' operation.
    pub fn sparse_values(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'sparse_dense_shape' Output of this 'RaggedTensorToSparse' operation.
    pub fn sparse_dense_shape(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns a Vector of rt_nested_splits for 'rt_nested_splits' Input of this RaggedTensorToSparse operation.
    pub fn rt_nested_splits(&self) -> crate::Result<Vec<crate::Input>> {
        let mut Inputs = vec![];
        for i in 0..self.op.get_attr_int("RAGGED_RANK")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
    /// Returns the 'rt_dense_values' Input of this 'RaggedTensorToSparse' operation.
    pub fn rt_dense_values(&self) -> crate::Result<crate::Input> {
        let dynamic_offset = (self.op.get_attr_int("RAGGED_RANK")? + 1) as i32;
        Ok(crate::Input {
            operation: &self.op,
            index: dynamic_offset,
        })
    }
}
impl From<RaggedTensorToSparseInst> for crate::Operation {
    fn from(inst: RaggedTensorToSparseInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RaggedTensorToSparse::new().build(rt_nested_splits, rt_dense_values, scope)`.
pub fn ragged_tensor_to_sparse<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    rt_nested_splits: O0,
    rt_dense_values: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RaggedTensorToSparse::new().build(rt_nested_splits, rt_dense_values, scope)
}

/// Builder for the `RaggedTensorToTensor` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RaggedTensorToTensor {
    T: ::std::option::Option<crate::DataType>,
    Tindex: ::std::option::Option<crate::DataType>,
    Tshape: ::std::option::Option<crate::DataType>,
    num_row_partition_tensors: ::std::option::Option<i64>,
    row_partition_types: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RaggedTensorToTensor' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RaggedTensorToTensorInst {
    /// An instance of a fully built RaggedTensorToTensor Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RaggedTensorToTensor {
    /// Creates a new `RaggedTensorToTensor`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tindex` attribute.
    pub fn Tindex<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tindex = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tshape` attribute.
    pub fn Tshape<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tshape = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `num_row_partition_tensors` attribute.
    pub fn num_row_partition_tensors<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.num_row_partition_tensors = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `row_partition_types` attribute.
    pub fn row_partition_types<
        ArgType: ::std::convert::Into<::std::vec::Vec<::std::string::String>>,
    >(
        mut self,
        value: ArgType,
    ) -> Self {
        self.row_partition_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RaggedTensorToTensor` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
    >(
        &self,
        shape: O0,
        values: O1,
        default_value: O2,
        row_partition_tensors: O3,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            shape.into(),
            values.into(),
            default_value.into(),
            row_partition_tensors.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        shape: crate::Output,
        values: crate::Output,
        default_value: crate::Output,
        row_partition_tensors: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("RaggedTensorToTensor", |nd| {
            nd.add_input(shape);
            nd.add_input(values);
            nd.add_input(default_value);
            nd.add_input(row_partition_tensors);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindex {
                nd.set_attr_type("Tindex", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tshape {
                nd.set_attr_type("Tshape", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_row_partition_tensors {
                nd.set_attr_int("num_row_partition_tensors", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.row_partition_types {
                nd.set_attr_string_list("row_partition_types", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RaggedTensorToTensor' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        shape: crate::Output,
        values: crate::Output,
        default_value: crate::Output,
        row_partition_tensors: Vec<crate::Output>,
        scope: &mut crate::Scope,
    ) -> crate::Result<RaggedTensorToTensorInst> {
        let op = scope.new_operation("RaggedTensorToTensor", |builder| {
            builder.add_input(shape);
            builder.add_input(values);
            builder.add_input(default_value);
            builder.add_input_list(&row_partition_tensors);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindex {
                builder.set_attr_type("Tindex", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tshape {
                builder.set_attr_type("Tshape", *value)?;
            }
            builder.set_attr_int(
                "num_row_partition_tensors",
                row_partition_tensors.clone().len() as i64,
            )?;
            if let ::std::option::Option::Some(value) = &self.row_partition_types {
                builder.set_attr_string_list("row_partition_types", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RaggedTensorToTensorInst { op })
    }
}
impl RaggedTensorToTensorInst {
    /// Returns the 'result' Output of this 'RaggedTensorToTensor' operation.
    pub fn result(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'shape' Input of this 'RaggedTensorToTensor' operation.
    pub fn shape(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'values' Input of this 'RaggedTensorToTensor' operation.
    pub fn values(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'default_value' Input of this 'RaggedTensorToTensor' operation.
    pub fn default_value(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns a Vector of row_partition_tensors for 'row_partition_tensors' Input of this RaggedTensorToTensor operation.
    pub fn row_partition_tensors(&self) -> crate::Result<Vec<crate::Input>> {
        let mut Inputs = vec![];
        for i in 3..self.op.get_attr_int("num_row_partition_tensors")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
}
impl From<RaggedTensorToTensorInst> for crate::Operation {
    fn from(inst: RaggedTensorToTensorInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RaggedTensorToTensor::new().build(shape, values, default_value, row_partition_tensors, scope)`.
pub fn ragged_tensor_to_tensor<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
>(
    shape: O0,
    values: O1,
    default_value: O2,
    row_partition_tensors: O3,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RaggedTensorToTensor::new().build(shape, values, default_value, row_partition_tensors, scope)
}

/// Builder for the `RaggedTensorToVariant` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RaggedTensorToVariant {
    RAGGED_RANK: ::std::option::Option<i64>,
    Tvalues: ::std::option::Option<crate::DataType>,
    Tsplits: ::std::option::Option<crate::DataType>,
    batched_input: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RaggedTensorToVariant' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RaggedTensorToVariantInst {
    /// An instance of a fully built RaggedTensorToVariant Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RaggedTensorToVariant {
    /// Creates a new `RaggedTensorToVariant`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `RAGGED_RANK` attribute.
    pub fn RAGGED_RANK<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.RAGGED_RANK = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tvalues` attribute.
    pub fn Tvalues<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tvalues = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tsplits` attribute.
    pub fn Tsplits<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tsplits = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `batched_input` attribute.
    pub fn batched_input<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.batched_input = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RaggedTensorToVariant` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        rt_nested_splits: O0,
        rt_dense_values: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(rt_nested_splits.into(), rt_dense_values.into(), scope)
    }
    fn build_impl(
        &self,
        rt_nested_splits: crate::Output,
        rt_dense_values: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("RaggedTensorToVariant", |nd| {
            nd.add_input(rt_nested_splits);
            nd.add_input(rt_dense_values);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.RAGGED_RANK {
                nd.set_attr_int("RAGGED_RANK", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tvalues {
                nd.set_attr_type("Tvalues", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tsplits {
                nd.set_attr_type("Tsplits", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.batched_input {
                nd.set_attr_bool("batched_input", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RaggedTensorToVariant' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        rt_nested_splits: Vec<crate::Output>,
        rt_dense_values: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<RaggedTensorToVariantInst> {
        let op = scope.new_operation("RaggedTensorToVariant", |builder| {
            builder.add_input_list(&rt_nested_splits);
            builder.add_input(rt_dense_values);
            builder.set_attr_int("RAGGED_RANK", rt_nested_splits.clone().len() as i64)?;
            if let ::std::option::Option::Some(value) = &self.Tvalues {
                builder.set_attr_type("Tvalues", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tsplits {
                builder.set_attr_type("Tsplits", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.batched_input {
                builder.set_attr_bool("batched_input", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RaggedTensorToVariantInst { op })
    }
}
impl RaggedTensorToVariantInst {
    /// Returns the 'encoded_ragged' Output of this 'RaggedTensorToVariant' operation.
    pub fn encoded_ragged(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns a Vector of rt_nested_splits for 'rt_nested_splits' Input of this RaggedTensorToVariant operation.
    pub fn rt_nested_splits(&self) -> crate::Result<Vec<crate::Input>> {
        let mut Inputs = vec![];
        for i in 0..self.op.get_attr_int("RAGGED_RANK")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
    /// Returns the 'rt_dense_values' Input of this 'RaggedTensorToVariant' operation.
    pub fn rt_dense_values(&self) -> crate::Result<crate::Input> {
        let dynamic_offset = (self.op.get_attr_int("RAGGED_RANK")? + 1) as i32;
        Ok(crate::Input {
            operation: &self.op,
            index: dynamic_offset,
        })
    }
}
impl From<RaggedTensorToVariantInst> for crate::Operation {
    fn from(inst: RaggedTensorToVariantInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RaggedTensorToVariant::new().build(rt_nested_splits, rt_dense_values, scope)`.
pub fn ragged_tensor_to_variant<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    rt_nested_splits: O0,
    rt_dense_values: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RaggedTensorToVariant::new().build(rt_nested_splits, rt_dense_values, scope)
}

/// Builder for the `RaggedTensorToVariantGradient` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RaggedTensorToVariantGradient {
    Tvalues: ::std::option::Option<crate::DataType>,
    Tsplits: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RaggedTensorToVariantGradient' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RaggedTensorToVariantGradientInst {
    /// An instance of a fully built RaggedTensorToVariantGradient Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RaggedTensorToVariantGradient {
    /// Creates a new `RaggedTensorToVariantGradient`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `Tvalues` attribute.
    pub fn Tvalues<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tvalues = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tsplits` attribute.
    pub fn Tsplits<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tsplits = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RaggedTensorToVariantGradient` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        encoded_ragged_grad: O0,
        row_splits: O1,
        dense_values_shape: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            encoded_ragged_grad.into(),
            row_splits.into(),
            dense_values_shape.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        encoded_ragged_grad: crate::Output,
        row_splits: crate::Output,
        dense_values_shape: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("RaggedTensorToVariantGradient", |nd| {
            nd.add_input(encoded_ragged_grad);
            nd.add_input(row_splits);
            nd.add_input(dense_values_shape);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.Tvalues {
                nd.set_attr_type("Tvalues", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tsplits {
                nd.set_attr_type("Tsplits", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RaggedTensorToVariantGradient' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        encoded_ragged_grad: crate::Output,
        row_splits: crate::Output,
        dense_values_shape: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<RaggedTensorToVariantGradientInst> {
        let op = scope.new_operation("RaggedTensorToVariantGradient", |builder| {
            builder.add_input(encoded_ragged_grad);
            builder.add_input(row_splits);
            builder.add_input(dense_values_shape);
            if let ::std::option::Option::Some(value) = &self.Tvalues {
                builder.set_attr_type("Tvalues", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tsplits {
                builder.set_attr_type("Tsplits", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RaggedTensorToVariantGradientInst { op })
    }
}
impl RaggedTensorToVariantGradientInst {
    /// Returns the 'dense_values_grad' Output of this 'RaggedTensorToVariantGradient' operation.
    pub fn dense_values_grad(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'encoded_ragged_grad' Input of this 'RaggedTensorToVariantGradient' operation.
    pub fn encoded_ragged_grad(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'row_splits' Input of this 'RaggedTensorToVariantGradient' operation.
    pub fn row_splits(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'dense_values_shape' Input of this 'RaggedTensorToVariantGradient' operation.
    pub fn dense_values_shape(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<RaggedTensorToVariantGradientInst> for crate::Operation {
    fn from(inst: RaggedTensorToVariantGradientInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RaggedTensorToVariantGradient::new().build(encoded_ragged_grad, row_splits, dense_values_shape, scope)`.
pub fn ragged_tensor_to_variant_gradient<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    encoded_ragged_grad: O0,
    row_splits: O1,
    dense_values_shape: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RaggedTensorToVariantGradient::new().build(
        encoded_ragged_grad,
        row_splits,
        dense_values_shape,
        scope,
    )
}

/// Builder for the `RandomCrop` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RandomCrop {
    T: ::std::option::Option<crate::DataType>,
    seed: ::std::option::Option<i64>,
    seed2: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RandomCrop' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RandomCropInst {
    /// An instance of a fully built RandomCrop Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RandomCrop {
    /// Creates a new `RandomCrop`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `seed` attribute.
    pub fn seed<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.seed = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `seed2` attribute.
    pub fn seed2<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.seed2 = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RandomCrop` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        image: O0,
        size: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(image.into(), size.into(), scope)
    }
    fn build_impl(
        &self,
        image: crate::Output,
        size: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("RandomCrop", |nd| {
            nd.add_input(image);
            nd.add_input(size);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed {
                nd.set_attr_int("seed", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed2 {
                nd.set_attr_int("seed2", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RandomCrop' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        image: crate::Output,
        size: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<RandomCropInst> {
        let op = scope.new_operation("RandomCrop", |builder| {
            builder.add_input(image);
            builder.add_input(size);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed {
                builder.set_attr_int("seed", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed2 {
                builder.set_attr_int("seed2", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RandomCropInst { op })
    }
}
impl RandomCropInst {
    /// Returns the 'output' Output of this 'RandomCrop' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'image' Input of this 'RandomCrop' operation.
    pub fn image(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'size' Input of this 'RandomCrop' operation.
    pub fn size(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<RandomCropInst> for crate::Operation {
    fn from(inst: RandomCropInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RandomCrop::new().build(image, size, scope)`.
pub fn random_crop<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    image: O0,
    size: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RandomCrop::new().build(image, size, scope)
}

/// Builder for the `RandomDataset` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RandomDataset {
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    metadata: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RandomDataset' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RandomDatasetInst {
    /// An instance of a fully built RandomDataset Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RandomDataset {
    /// Creates a new `RandomDataset`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `metadata` attribute.
    pub fn metadata<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.metadata = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RandomDataset` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        seed: O0,
        seed2: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(seed.into(), seed2.into(), scope)
    }
    fn build_impl(
        &self,
        seed: crate::Output,
        seed2: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("RandomDataset", |nd| {
            nd.add_input(seed);
            nd.add_input(seed2);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.metadata {
                nd.set_attr_string("metadata", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RandomDataset' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        seed: crate::Output,
        seed2: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<RandomDatasetInst> {
        let op = scope.new_operation("RandomDataset", |builder| {
            builder.add_input(seed);
            builder.add_input(seed2);
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.metadata {
                builder.set_attr_string("metadata", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RandomDatasetInst { op })
    }
}
impl RandomDatasetInst {
    /// Returns the 'handle' Output of this 'RandomDataset' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'seed' Input of this 'RandomDataset' operation.
    pub fn seed(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'seed2' Input of this 'RandomDataset' operation.
    pub fn seed2(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<RandomDatasetInst> for crate::Operation {
    fn from(inst: RandomDatasetInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RandomDataset::new().build(seed, seed2, scope)`.
pub fn random_dataset<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    seed: O0,
    seed2: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RandomDataset::new().build(seed, seed2, scope)
}

/// Builder for the `RandomDatasetV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RandomDatasetV2 {
    rerandomize_each_iteration: ::std::option::Option<bool>,
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    metadata: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RandomDatasetV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RandomDatasetV2Inst {
    /// An instance of a fully built RandomDatasetV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RandomDatasetV2 {
    /// Creates a new `RandomDatasetV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `rerandomize_each_iteration` attribute.
    pub fn rerandomize_each_iteration<ArgType: ::std::convert::Into<bool>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.rerandomize_each_iteration = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `metadata` attribute.
    pub fn metadata<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.metadata = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RandomDatasetV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        seed: O0,
        seed2: O1,
        seed_generator: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(seed.into(), seed2.into(), seed_generator.into(), scope)
    }
    fn build_impl(
        &self,
        seed: crate::Output,
        seed2: crate::Output,
        seed_generator: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("RandomDatasetV2", |nd| {
            nd.add_input(seed);
            nd.add_input(seed2);
            nd.add_input(seed_generator);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.rerandomize_each_iteration {
                nd.set_attr_bool("rerandomize_each_iteration", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.metadata {
                nd.set_attr_string("metadata", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RandomDatasetV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        seed: crate::Output,
        seed2: crate::Output,
        seed_generator: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<RandomDatasetV2Inst> {
        let op = scope.new_operation("RandomDatasetV2", |builder| {
            builder.add_input(seed);
            builder.add_input(seed2);
            builder.add_input(seed_generator);
            if let ::std::option::Option::Some(value) = &self.rerandomize_each_iteration {
                builder.set_attr_bool("rerandomize_each_iteration", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.metadata {
                builder.set_attr_string("metadata", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RandomDatasetV2Inst { op })
    }
}
impl RandomDatasetV2Inst {
    /// Returns the 'handle' Output of this 'RandomDatasetV2' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'seed' Input of this 'RandomDatasetV2' operation.
    pub fn seed(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'seed2' Input of this 'RandomDatasetV2' operation.
    pub fn seed2(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'seed_generator' Input of this 'RandomDatasetV2' operation.
    pub fn seed_generator(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<RandomDatasetV2Inst> for crate::Operation {
    fn from(inst: RandomDatasetV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RandomDatasetV2::new().build(seed, seed2, seed_generator, scope)`.
pub fn random_dataset_v2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    seed: O0,
    seed2: O1,
    seed_generator: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RandomDatasetV2::new().build(seed, seed2, seed_generator, scope)
}

/// Builder for the `RandomGamma` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RandomGamma {
    seed: ::std::option::Option<i64>,
    seed2: ::std::option::Option<i64>,
    S: ::std::option::Option<crate::DataType>,
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RandomGamma' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RandomGammaInst {
    /// An instance of a fully built RandomGamma Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RandomGamma {
    /// Creates a new `RandomGamma`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `seed` attribute.
    pub fn seed<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.seed = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `seed2` attribute.
    pub fn seed2<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.seed2 = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `S` attribute.
    pub fn S<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.S = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RandomGamma` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        shape: O0,
        alpha: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(shape.into(), alpha.into(), scope)
    }
    fn build_impl(
        &self,
        shape: crate::Output,
        alpha: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("RandomGamma", |nd| {
            nd.add_input(shape);
            nd.add_input(alpha);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.seed {
                nd.set_attr_int("seed", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed2 {
                nd.set_attr_int("seed2", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.S {
                nd.set_attr_type("S", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RandomGamma' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        shape: crate::Output,
        alpha: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<RandomGammaInst> {
        let op = scope.new_operation("RandomGamma", |builder| {
            builder.add_input(shape);
            builder.add_input(alpha);
            if let ::std::option::Option::Some(value) = &self.seed {
                builder.set_attr_int("seed", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed2 {
                builder.set_attr_int("seed2", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.S {
                builder.set_attr_type("S", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RandomGammaInst { op })
    }
}
impl RandomGammaInst {
    /// Returns the 'output' Output of this 'RandomGamma' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'shape' Input of this 'RandomGamma' operation.
    pub fn shape(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'alpha' Input of this 'RandomGamma' operation.
    pub fn alpha(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<RandomGammaInst> for crate::Operation {
    fn from(inst: RandomGammaInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RandomGamma::new().build(shape, alpha, scope)`.
pub fn random_gamma<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    shape: O0,
    alpha: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RandomGamma::new().build(shape, alpha, scope)
}

/// Builder for the `RandomGammaGrad` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RandomGammaGrad {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RandomGammaGrad' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RandomGammaGradInst {
    /// An instance of a fully built RandomGammaGrad Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RandomGammaGrad {
    /// Creates a new `RandomGammaGrad`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RandomGammaGrad` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        alpha: O0,
        sample: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(alpha.into(), sample.into(), scope)
    }
    fn build_impl(
        &self,
        alpha: crate::Output,
        sample: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("RandomGammaGrad", |nd| {
            nd.add_input(alpha);
            nd.add_input(sample);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RandomGammaGrad' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        alpha: crate::Output,
        sample: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<RandomGammaGradInst> {
        let op = scope.new_operation("RandomGammaGrad", |builder| {
            builder.add_input(alpha);
            builder.add_input(sample);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RandomGammaGradInst { op })
    }
}
impl RandomGammaGradInst {
    /// Returns the 'output' Output of this 'RandomGammaGrad' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'alpha' Input of this 'RandomGammaGrad' operation.
    pub fn alpha(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'sample' Input of this 'RandomGammaGrad' operation.
    pub fn sample(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<RandomGammaGradInst> for crate::Operation {
    fn from(inst: RandomGammaGradInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RandomGammaGrad::new().build(alpha, sample, scope)`.
pub fn random_gamma_grad<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    alpha: O0,
    sample: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RandomGammaGrad::new().build(alpha, sample, scope)
}

/// Builder for the `RandomIndexShuffle` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RandomIndexShuffle {
    rounds: ::std::option::Option<i64>,
    dtype: ::std::option::Option<crate::DataType>,
    Tseed: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RandomIndexShuffle' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RandomIndexShuffleInst {
    /// An instance of a fully built RandomIndexShuffle Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RandomIndexShuffle {
    /// Creates a new `RandomIndexShuffle`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `rounds` attribute.
    pub fn rounds<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.rounds = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `dtype` attribute.
    pub fn dtype<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tseed` attribute.
    pub fn Tseed<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Tseed = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RandomIndexShuffle` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        index: O0,
        seed: O1,
        max_index: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(index.into(), seed.into(), max_index.into(), scope)
    }
    fn build_impl(
        &self,
        index: crate::Output,
        seed: crate::Output,
        max_index: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("RandomIndexShuffle", |nd| {
            nd.add_input(index);
            nd.add_input(seed);
            nd.add_input(max_index);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.rounds {
                nd.set_attr_int("rounds", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                nd.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tseed {
                nd.set_attr_type("Tseed", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RandomIndexShuffle' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        index: crate::Output,
        seed: crate::Output,
        max_index: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<RandomIndexShuffleInst> {
        let op = scope.new_operation("RandomIndexShuffle", |builder| {
            builder.add_input(index);
            builder.add_input(seed);
            builder.add_input(max_index);
            if let ::std::option::Option::Some(value) = &self.rounds {
                builder.set_attr_int("rounds", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                builder.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tseed {
                builder.set_attr_type("Tseed", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RandomIndexShuffleInst { op })
    }
}
impl RandomIndexShuffleInst {
    /// Returns the 'output' Output of this 'RandomIndexShuffle' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'index' Input of this 'RandomIndexShuffle' operation.
    pub fn index(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'seed' Input of this 'RandomIndexShuffle' operation.
    pub fn seed(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'max_index' Input of this 'RandomIndexShuffle' operation.
    pub fn max_index(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<RandomIndexShuffleInst> for crate::Operation {
    fn from(inst: RandomIndexShuffleInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RandomIndexShuffle::new().build(index, seed, max_index, scope)`.
pub fn random_index_shuffle<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    index: O0,
    seed: O1,
    max_index: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RandomIndexShuffle::new().build(index, seed, max_index, scope)
}

/// Builder for the `RandomPoisson` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RandomPoisson {
    seed: ::std::option::Option<i64>,
    seed2: ::std::option::Option<i64>,
    S: ::std::option::Option<crate::DataType>,
    dtype: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RandomPoisson' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RandomPoissonInst {
    /// An instance of a fully built RandomPoisson Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RandomPoisson {
    /// Creates a new `RandomPoisson`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `seed` attribute.
    pub fn seed<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.seed = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `seed2` attribute.
    pub fn seed2<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.seed2 = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `S` attribute.
    pub fn S<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.S = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `dtype` attribute.
    pub fn dtype<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RandomPoisson` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        shape: O0,
        rate: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(shape.into(), rate.into(), scope)
    }
    fn build_impl(
        &self,
        shape: crate::Output,
        rate: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("RandomPoisson", |nd| {
            nd.add_input(shape);
            nd.add_input(rate);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.seed {
                nd.set_attr_int("seed", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed2 {
                nd.set_attr_int("seed2", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.S {
                nd.set_attr_type("S", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                nd.set_attr_type("dtype", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RandomPoisson' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        shape: crate::Output,
        rate: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<RandomPoissonInst> {
        let op = scope.new_operation("RandomPoisson", |builder| {
            builder.add_input(shape);
            builder.add_input(rate);
            if let ::std::option::Option::Some(value) = &self.seed {
                builder.set_attr_int("seed", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed2 {
                builder.set_attr_int("seed2", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.S {
                builder.set_attr_type("S", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                builder.set_attr_type("dtype", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RandomPoissonInst { op })
    }
}
impl RandomPoissonInst {
    /// Returns the 'output' Output of this 'RandomPoisson' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'shape' Input of this 'RandomPoisson' operation.
    pub fn shape(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'rate' Input of this 'RandomPoisson' operation.
    pub fn rate(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<RandomPoissonInst> for crate::Operation {
    fn from(inst: RandomPoissonInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RandomPoisson::new().build(shape, rate, scope)`.
pub fn random_poisson<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    shape: O0,
    rate: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RandomPoisson::new().build(shape, rate, scope)
}

/// Builder for the `RandomPoissonV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RandomPoissonV2 {
    seed: ::std::option::Option<i64>,
    seed2: ::std::option::Option<i64>,
    S: ::std::option::Option<crate::DataType>,
    R: ::std::option::Option<crate::DataType>,
    dtype: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RandomPoissonV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RandomPoissonV2Inst {
    /// An instance of a fully built RandomPoissonV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RandomPoissonV2 {
    /// Creates a new `RandomPoissonV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `seed` attribute.
    pub fn seed<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.seed = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `seed2` attribute.
    pub fn seed2<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.seed2 = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `S` attribute.
    pub fn S<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.S = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `R` attribute.
    pub fn R<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.R = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `dtype` attribute.
    pub fn dtype<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RandomPoissonV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        shape: O0,
        rate: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(shape.into(), rate.into(), scope)
    }
    fn build_impl(
        &self,
        shape: crate::Output,
        rate: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("RandomPoissonV2", |nd| {
            nd.add_input(shape);
            nd.add_input(rate);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.seed {
                nd.set_attr_int("seed", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed2 {
                nd.set_attr_int("seed2", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.S {
                nd.set_attr_type("S", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.R {
                nd.set_attr_type("R", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                nd.set_attr_type("dtype", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RandomPoissonV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        shape: crate::Output,
        rate: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<RandomPoissonV2Inst> {
        let op = scope.new_operation("RandomPoissonV2", |builder| {
            builder.add_input(shape);
            builder.add_input(rate);
            if let ::std::option::Option::Some(value) = &self.seed {
                builder.set_attr_int("seed", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed2 {
                builder.set_attr_int("seed2", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.S {
                builder.set_attr_type("S", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.R {
                builder.set_attr_type("R", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                builder.set_attr_type("dtype", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RandomPoissonV2Inst { op })
    }
}
impl RandomPoissonV2Inst {
    /// Returns the 'output' Output of this 'RandomPoissonV2' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'shape' Input of this 'RandomPoissonV2' operation.
    pub fn shape(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'rate' Input of this 'RandomPoissonV2' operation.
    pub fn rate(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<RandomPoissonV2Inst> for crate::Operation {
    fn from(inst: RandomPoissonV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RandomPoissonV2::new().build(shape, rate, scope)`.
pub fn random_poisson_v2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    shape: O0,
    rate: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RandomPoissonV2::new().build(shape, rate, scope)
}

/// Builder for the `RandomShuffle` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RandomShuffle {
    seed: ::std::option::Option<i64>,
    seed2: ::std::option::Option<i64>,
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RandomShuffle' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RandomShuffleInst {
    /// An instance of a fully built RandomShuffle Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RandomShuffle {
    /// Creates a new `RandomShuffle`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `seed` attribute.
    pub fn seed<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.seed = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `seed2` attribute.
    pub fn seed2<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.seed2 = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RandomShuffle` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        value: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(value.into(), scope)
    }
    fn build_impl(
        &self,
        value: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("RandomShuffle", |nd| {
            nd.add_input(value);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.seed {
                nd.set_attr_int("seed", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed2 {
                nd.set_attr_int("seed2", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RandomShuffle' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        value: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<RandomShuffleInst> {
        let op = scope.new_operation("RandomShuffle", |builder| {
            builder.add_input(value);
            if let ::std::option::Option::Some(value) = &self.seed {
                builder.set_attr_int("seed", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed2 {
                builder.set_attr_int("seed2", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RandomShuffleInst { op })
    }
}
impl RandomShuffleInst {
    /// Returns the 'output' Output of this 'RandomShuffle' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'value' Input of this 'RandomShuffle' operation.
    pub fn value(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<RandomShuffleInst> for crate::Operation {
    fn from(inst: RandomShuffleInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RandomShuffle::new().build(value, scope)`.
pub fn random_shuffle<O0: ::std::convert::Into<crate::Output>>(
    value: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RandomShuffle::new().build(value, scope)
}

/// Builder for the `RandomShuffleQueue` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RandomShuffleQueue {
    component_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    capacity: ::std::option::Option<i64>,
    min_after_dequeue: ::std::option::Option<i64>,
    seed: ::std::option::Option<i64>,
    seed2: ::std::option::Option<i64>,
    container: ::std::option::Option<::std::string::String>,
    shared_name: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RandomShuffleQueue' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RandomShuffleQueueInst {
    /// An instance of a fully built RandomShuffleQueue Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RandomShuffleQueue {
    /// Creates a new `RandomShuffleQueue`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `component_types` attribute.
    pub fn component_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.component_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shapes` attribute.
    pub fn shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `capacity` attribute.
    pub fn capacity<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.capacity = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `min_after_dequeue` attribute.
    pub fn min_after_dequeue<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.min_after_dequeue = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `seed` attribute.
    pub fn seed<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.seed = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `seed2` attribute.
    pub fn seed2<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.seed2 = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `container` attribute.
    pub fn container<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.container = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shared_name` attribute.
    pub fn shared_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.shared_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RandomShuffleQueue` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("RandomShuffleQueue", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.component_types {
                nd.set_attr_type_list("component_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shapes {
                nd.set_attr_shape_list("shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.capacity {
                nd.set_attr_int("capacity", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.min_after_dequeue {
                nd.set_attr_int("min_after_dequeue", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed {
                nd.set_attr_int("seed", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed2 {
                nd.set_attr_int("seed2", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.container {
                nd.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                nd.set_attr_string("shared_name", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RandomShuffleQueue' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        scope: &mut crate::Scope,
    ) -> crate::Result<RandomShuffleQueueInst> {
        let op = scope.new_operation("RandomShuffleQueue", |builder| {
            if let ::std::option::Option::Some(value) = &self.component_types {
                builder.set_attr_type_list("component_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shapes {
                builder.set_attr_shape_list("shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.capacity {
                builder.set_attr_int("capacity", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.min_after_dequeue {
                builder.set_attr_int("min_after_dequeue", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed {
                builder.set_attr_int("seed", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed2 {
                builder.set_attr_int("seed2", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.container {
                builder.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                builder.set_attr_string("shared_name", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RandomShuffleQueueInst { op })
    }
}
impl RandomShuffleQueueInst {
    /// Returns the 'handle' Output of this 'RandomShuffleQueue' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
}
impl From<RandomShuffleQueueInst> for crate::Operation {
    fn from(inst: RandomShuffleQueueInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RandomShuffleQueue::new().build(scope)`.
pub fn random_shuffle_queue(scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
    RandomShuffleQueue::new().build(scope)
}

/// Builder for the `RandomShuffleQueueV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RandomShuffleQueueV2 {
    component_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    capacity: ::std::option::Option<i64>,
    min_after_dequeue: ::std::option::Option<i64>,
    seed: ::std::option::Option<i64>,
    seed2: ::std::option::Option<i64>,
    container: ::std::option::Option<::std::string::String>,
    shared_name: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RandomShuffleQueueV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RandomShuffleQueueV2Inst {
    /// An instance of a fully built RandomShuffleQueueV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RandomShuffleQueueV2 {
    /// Creates a new `RandomShuffleQueueV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `component_types` attribute.
    pub fn component_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.component_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shapes` attribute.
    pub fn shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `capacity` attribute.
    pub fn capacity<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.capacity = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `min_after_dequeue` attribute.
    pub fn min_after_dequeue<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.min_after_dequeue = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `seed` attribute.
    pub fn seed<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.seed = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `seed2` attribute.
    pub fn seed2<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.seed2 = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `container` attribute.
    pub fn container<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.container = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shared_name` attribute.
    pub fn shared_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.shared_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RandomShuffleQueueV2` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("RandomShuffleQueueV2", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.component_types {
                nd.set_attr_type_list("component_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shapes {
                nd.set_attr_shape_list("shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.capacity {
                nd.set_attr_int("capacity", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.min_after_dequeue {
                nd.set_attr_int("min_after_dequeue", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed {
                nd.set_attr_int("seed", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed2 {
                nd.set_attr_int("seed2", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.container {
                nd.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                nd.set_attr_string("shared_name", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RandomShuffleQueueV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        scope: &mut crate::Scope,
    ) -> crate::Result<RandomShuffleQueueV2Inst> {
        let op = scope.new_operation("RandomShuffleQueueV2", |builder| {
            if let ::std::option::Option::Some(value) = &self.component_types {
                builder.set_attr_type_list("component_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shapes {
                builder.set_attr_shape_list("shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.capacity {
                builder.set_attr_int("capacity", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.min_after_dequeue {
                builder.set_attr_int("min_after_dequeue", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed {
                builder.set_attr_int("seed", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed2 {
                builder.set_attr_int("seed2", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.container {
                builder.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                builder.set_attr_string("shared_name", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RandomShuffleQueueV2Inst { op })
    }
}
impl RandomShuffleQueueV2Inst {
    /// Returns the 'handle' Output of this 'RandomShuffleQueueV2' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
}
impl From<RandomShuffleQueueV2Inst> for crate::Operation {
    fn from(inst: RandomShuffleQueueV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RandomShuffleQueueV2::new().build(scope)`.
pub fn random_shuffle_queue_v2(scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
    RandomShuffleQueueV2::new().build(scope)
}

/// Builder for the `RandomStandardNormal` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RandomStandardNormal {
    seed: ::std::option::Option<i64>,
    seed2: ::std::option::Option<i64>,
    dtype: ::std::option::Option<crate::DataType>,
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RandomStandardNormal' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RandomStandardNormalInst {
    /// An instance of a fully built RandomStandardNormal Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RandomStandardNormal {
    /// Creates a new `RandomStandardNormal`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `seed` attribute.
    pub fn seed<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.seed = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `seed2` attribute.
    pub fn seed2<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.seed2 = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `dtype` attribute.
    pub fn dtype<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RandomStandardNormal` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        shape: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(shape.into(), scope)
    }
    fn build_impl(
        &self,
        shape: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("RandomStandardNormal", |nd| {
            nd.add_input(shape);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.seed {
                nd.set_attr_int("seed", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed2 {
                nd.set_attr_int("seed2", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                nd.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RandomStandardNormal' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        shape: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<RandomStandardNormalInst> {
        let op = scope.new_operation("RandomStandardNormal", |builder| {
            builder.add_input(shape);
            if let ::std::option::Option::Some(value) = &self.seed {
                builder.set_attr_int("seed", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed2 {
                builder.set_attr_int("seed2", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                builder.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RandomStandardNormalInst { op })
    }
}
impl RandomStandardNormalInst {
    /// Returns the 'output' Output of this 'RandomStandardNormal' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'shape' Input of this 'RandomStandardNormal' operation.
    pub fn shape(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<RandomStandardNormalInst> for crate::Operation {
    fn from(inst: RandomStandardNormalInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RandomStandardNormal::new().build(shape, scope)`.
pub fn random_standard_normal<O0: ::std::convert::Into<crate::Output>>(
    shape: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RandomStandardNormal::new().build(shape, scope)
}

/// Builder for the `RandomUniform` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RandomUniform {
    seed: ::std::option::Option<i64>,
    seed2: ::std::option::Option<i64>,
    dtype: ::std::option::Option<crate::DataType>,
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RandomUniform' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RandomUniformInst {
    /// An instance of a fully built RandomUniform Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RandomUniform {
    /// Creates a new `RandomUniform`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `seed` attribute.
    pub fn seed<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.seed = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `seed2` attribute.
    pub fn seed2<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.seed2 = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `dtype` attribute.
    pub fn dtype<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RandomUniform` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        shape: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(shape.into(), scope)
    }
    fn build_impl(
        &self,
        shape: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("RandomUniform", |nd| {
            nd.add_input(shape);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.seed {
                nd.set_attr_int("seed", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed2 {
                nd.set_attr_int("seed2", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                nd.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RandomUniform' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        shape: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<RandomUniformInst> {
        let op = scope.new_operation("RandomUniform", |builder| {
            builder.add_input(shape);
            if let ::std::option::Option::Some(value) = &self.seed {
                builder.set_attr_int("seed", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed2 {
                builder.set_attr_int("seed2", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                builder.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RandomUniformInst { op })
    }
}
impl RandomUniformInst {
    /// Returns the 'output' Output of this 'RandomUniform' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'shape' Input of this 'RandomUniform' operation.
    pub fn shape(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<RandomUniformInst> for crate::Operation {
    fn from(inst: RandomUniformInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RandomUniform::new().build(shape, scope)`.
pub fn random_uniform<O0: ::std::convert::Into<crate::Output>>(
    shape: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RandomUniform::new().build(shape, scope)
}

/// Builder for the `RandomUniformInt` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RandomUniformInt {
    seed: ::std::option::Option<i64>,
    seed2: ::std::option::Option<i64>,
    Tout: ::std::option::Option<crate::DataType>,
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RandomUniformInt' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RandomUniformIntInst {
    /// An instance of a fully built RandomUniformInt Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RandomUniformInt {
    /// Creates a new `RandomUniformInt`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `seed` attribute.
    pub fn seed<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.seed = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `seed2` attribute.
    pub fn seed2<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.seed2 = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tout` attribute.
    pub fn Tout<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Tout = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RandomUniformInt` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        shape: O0,
        minval: O1,
        maxval: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(shape.into(), minval.into(), maxval.into(), scope)
    }
    fn build_impl(
        &self,
        shape: crate::Output,
        minval: crate::Output,
        maxval: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("RandomUniformInt", |nd| {
            nd.add_input(shape);
            nd.add_input(minval);
            nd.add_input(maxval);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.seed {
                nd.set_attr_int("seed", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed2 {
                nd.set_attr_int("seed2", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tout {
                nd.set_attr_type("Tout", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RandomUniformInt' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        shape: crate::Output,
        minval: crate::Output,
        maxval: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<RandomUniformIntInst> {
        let op = scope.new_operation("RandomUniformInt", |builder| {
            builder.add_input(shape);
            builder.add_input(minval);
            builder.add_input(maxval);
            if let ::std::option::Option::Some(value) = &self.seed {
                builder.set_attr_int("seed", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed2 {
                builder.set_attr_int("seed2", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tout {
                builder.set_attr_type("Tout", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RandomUniformIntInst { op })
    }
}
impl RandomUniformIntInst {
    /// Returns the 'output' Output of this 'RandomUniformInt' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'shape' Input of this 'RandomUniformInt' operation.
    pub fn shape(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'minval' Input of this 'RandomUniformInt' operation.
    pub fn minval(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'maxval' Input of this 'RandomUniformInt' operation.
    pub fn maxval(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<RandomUniformIntInst> for crate::Operation {
    fn from(inst: RandomUniformIntInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RandomUniformInt::new().build(shape, minval, maxval, scope)`.
pub fn random_uniform_int<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    shape: O0,
    minval: O1,
    maxval: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RandomUniformInt::new().build(shape, minval, maxval, scope)
}

/// Builder for the `Range` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Range {
    Tidx: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Range' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RangeInst {
    /// An instance of a fully built Range Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Range {
    /// Creates a new `Range`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `Tidx` attribute.
    pub fn Tidx<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Tidx = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Range` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        start: O0,
        limit: O1,
        delta: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(start.into(), limit.into(), delta.into(), scope)
    }
    fn build_impl(
        &self,
        start: crate::Output,
        limit: crate::Output,
        delta: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Range", |nd| {
            nd.add_input(start);
            nd.add_input(limit);
            nd.add_input(delta);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.Tidx {
                nd.set_attr_type("Tidx", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Range' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        start: crate::Output,
        limit: crate::Output,
        delta: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<RangeInst> {
        let op = scope.new_operation("Range", |builder| {
            builder.add_input(start);
            builder.add_input(limit);
            builder.add_input(delta);
            if let ::std::option::Option::Some(value) = &self.Tidx {
                builder.set_attr_type("Tidx", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RangeInst { op })
    }
}
impl RangeInst {
    /// Returns the 'output' Output of this 'Range' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'start' Input of this 'Range' operation.
    pub fn start(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'limit' Input of this 'Range' operation.
    pub fn limit(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'delta' Input of this 'Range' operation.
    pub fn delta(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<RangeInst> for crate::Operation {
    fn from(inst: RangeInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Range::new().build(start, limit, delta, scope)`.
pub fn range<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    start: O0,
    limit: O1,
    delta: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Range::new().build(start, limit, delta, scope)
}

/// Builder for the `RangeDataset` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RangeDataset {
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    metadata: ::std::option::Option<::std::string::String>,
    replicate_on_split: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RangeDataset' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RangeDatasetInst {
    /// An instance of a fully built RangeDataset Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RangeDataset {
    /// Creates a new `RangeDataset`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `metadata` attribute.
    pub fn metadata<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.metadata = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `replicate_on_split` attribute.
    pub fn replicate_on_split<ArgType: ::std::convert::Into<bool>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.replicate_on_split = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RangeDataset` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        start: O0,
        stop: O1,
        step: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(start.into(), stop.into(), step.into(), scope)
    }
    fn build_impl(
        &self,
        start: crate::Output,
        stop: crate::Output,
        step: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("RangeDataset", |nd| {
            nd.add_input(start);
            nd.add_input(stop);
            nd.add_input(step);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.metadata {
                nd.set_attr_string("metadata", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.replicate_on_split {
                nd.set_attr_bool("replicate_on_split", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RangeDataset' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        start: crate::Output,
        stop: crate::Output,
        step: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<RangeDatasetInst> {
        let op = scope.new_operation("RangeDataset", |builder| {
            builder.add_input(start);
            builder.add_input(stop);
            builder.add_input(step);
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.metadata {
                builder.set_attr_string("metadata", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.replicate_on_split {
                builder.set_attr_bool("replicate_on_split", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RangeDatasetInst { op })
    }
}
impl RangeDatasetInst {
    /// Returns the 'handle' Output of this 'RangeDataset' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'start' Input of this 'RangeDataset' operation.
    pub fn start(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'stop' Input of this 'RangeDataset' operation.
    pub fn stop(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'step' Input of this 'RangeDataset' operation.
    pub fn step(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<RangeDatasetInst> for crate::Operation {
    fn from(inst: RangeDatasetInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RangeDataset::new().build(start, stop, step, scope)`.
pub fn range_dataset<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    start: O0,
    stop: O1,
    step: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RangeDataset::new().build(start, stop, step, scope)
}

/// Builder for the `Rank` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Rank {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Rank' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RankInst {
    /// An instance of a fully built Rank Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Rank {
    /// Creates a new `Rank`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Rank` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Rank", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Rank' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<RankInst> {
        let op = scope.new_operation("Rank", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RankInst { op })
    }
}
impl RankInst {
    /// Returns the 'output' Output of this 'Rank' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'Rank' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<RankInst> for crate::Operation {
    fn from(inst: RankInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Rank::new().build(input, scope)`.
pub fn rank<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Rank::new().build(input, scope)
}

/// Builder for the `ReadFile` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ReadFile {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ReadFile' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ReadFileInst {
    /// An instance of a fully built ReadFile Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ReadFile {
    /// Creates a new `ReadFile`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ReadFile` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        filename: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(filename.into(), scope)
    }
    fn build_impl(
        &self,
        filename: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ReadFile", |nd| {
            nd.add_input(filename);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ReadFile' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        filename: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ReadFileInst> {
        let op = scope.new_operation("ReadFile", |builder| {
            builder.add_input(filename);
            ::std::result::Result::Ok(())
        })?;
        Ok(ReadFileInst { op })
    }
}
impl ReadFileInst {
    /// Returns the 'contents' Output of this 'ReadFile' operation.
    pub fn contents(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'filename' Input of this 'ReadFile' operation.
    pub fn filename(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<ReadFileInst> for crate::Operation {
    fn from(inst: ReadFileInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ReadFile::new().build(filename, scope)`.
pub fn read_file<O0: ::std::convert::Into<crate::Output>>(
    filename: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ReadFile::new().build(filename, scope)
}

/// Builder for the `ReadVariableOp` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ReadVariableOp {
    dtype: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ReadVariableOp' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ReadVariableOpInst {
    /// An instance of a fully built ReadVariableOp Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ReadVariableOp {
    /// Creates a new `ReadVariableOp`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `dtype` attribute.
    pub fn dtype<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ReadVariableOp` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        resource: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(resource.into(), scope)
    }
    fn build_impl(
        &self,
        resource: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ReadVariableOp", |nd| {
            nd.add_input(resource);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                nd.set_attr_type("dtype", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ReadVariableOp' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        resource: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ReadVariableOpInst> {
        let op = scope.new_operation("ReadVariableOp", |builder| {
            builder.add_input(resource);
            if let ::std::option::Option::Some(value) = &self.dtype {
                builder.set_attr_type("dtype", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ReadVariableOpInst { op })
    }
}
impl ReadVariableOpInst {
    /// Returns the 'value' Output of this 'ReadVariableOp' operation.
    pub fn value(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'resource' Input of this 'ReadVariableOp' operation.
    pub fn resource(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<ReadVariableOpInst> for crate::Operation {
    fn from(inst: ReadVariableOpInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ReadVariableOp::new().build(resource, scope)`.
pub fn read_variable_op<O0: ::std::convert::Into<crate::Output>>(
    resource: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ReadVariableOp::new().build(resource, scope)
}

/// Builder for the `ReadVariableXlaSplitND` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ReadVariableXlaSplitND {
    T: ::std::option::Option<crate::DataType>,
    N: ::std::option::Option<i64>,
    num_splits: ::std::option::Option<::std::vec::Vec<i64>>,
    paddings: ::std::option::Option<::std::vec::Vec<i64>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ReadVariableXlaSplitND' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ReadVariableXlaSplitNDInst {
    /// An instance of a fully built ReadVariableXlaSplitND Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ReadVariableXlaSplitND {
    /// Creates a new `ReadVariableXlaSplitND`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `N` attribute.
    pub fn N<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.N = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `num_splits` attribute.
    pub fn num_splits<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.num_splits = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `paddings` attribute.
    pub fn paddings<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.paddings = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ReadVariableXlaSplitND` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        resource: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(resource.into(), scope)
    }
    fn build_impl(
        &self,
        resource: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ReadVariableXlaSplitND", |nd| {
            nd.add_input(resource);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.N {
                nd.set_attr_int("N", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_splits {
                nd.set_attr_int_list("num_splits", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.paddings {
                nd.set_attr_int_list("paddings", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ReadVariableXlaSplitND' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        resource: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ReadVariableXlaSplitNDInst> {
        let op = scope.new_operation("ReadVariableXlaSplitND", |builder| {
            builder.add_input(resource);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.N {
                builder.set_attr_int("N", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_splits {
                builder.set_attr_int_list("num_splits", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.paddings {
                builder.set_attr_int_list("paddings", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ReadVariableXlaSplitNDInst { op })
    }
}
impl ReadVariableXlaSplitNDInst {
    /// Returns a Vector of outputs for 'outputs' Output of this ReadVariableXlaSplitND operation.
    pub fn outputs(&self) -> crate::Result<Vec<crate::Output>> {
        let mut Outputs = vec![];
        for i in 0..self.op.get_attr_int("N")? as i32 {
            Outputs.push(crate::Output {
                operation: self.op.clone(),
                index: i,
            });
        }
        Ok(Outputs)
    }
    /// Returns the 'resource' Input of this 'ReadVariableXlaSplitND' operation.
    pub fn resource(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<ReadVariableXlaSplitNDInst> for crate::Operation {
    fn from(inst: ReadVariableXlaSplitNDInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ReadVariableXlaSplitND::new().build(resource, scope)`.
pub fn read_variable_xla_split_nd<O0: ::std::convert::Into<crate::Output>>(
    resource: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ReadVariableXlaSplitND::new().build(resource, scope)
}

/// Builder for the `ReaderNumRecordsProduced` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ReaderNumRecordsProduced {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ReaderNumRecordsProduced' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ReaderNumRecordsProducedInst {
    /// An instance of a fully built ReaderNumRecordsProduced Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ReaderNumRecordsProduced {
    /// Creates a new `ReaderNumRecordsProduced`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ReaderNumRecordsProduced` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        reader_handle: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(reader_handle.into(), scope)
    }
    fn build_impl(
        &self,
        reader_handle: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ReaderNumRecordsProduced", |nd| {
            nd.add_input(reader_handle);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ReaderNumRecordsProduced' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        reader_handle: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ReaderNumRecordsProducedInst> {
        let op = scope.new_operation("ReaderNumRecordsProduced", |builder| {
            builder.add_input(reader_handle);
            ::std::result::Result::Ok(())
        })?;
        Ok(ReaderNumRecordsProducedInst { op })
    }
}
impl ReaderNumRecordsProducedInst {
    /// Returns the 'records_produced' Output of this 'ReaderNumRecordsProduced' operation.
    pub fn records_produced(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'reader_handle' Input of this 'ReaderNumRecordsProduced' operation.
    pub fn reader_handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<ReaderNumRecordsProducedInst> for crate::Operation {
    fn from(inst: ReaderNumRecordsProducedInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ReaderNumRecordsProduced::new().build(reader_handle, scope)`.
pub fn reader_num_records_produced<O0: ::std::convert::Into<crate::Output>>(
    reader_handle: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ReaderNumRecordsProduced::new().build(reader_handle, scope)
}

/// Builder for the `ReaderNumRecordsProducedV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ReaderNumRecordsProducedV2 {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ReaderNumRecordsProducedV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ReaderNumRecordsProducedV2Inst {
    /// An instance of a fully built ReaderNumRecordsProducedV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ReaderNumRecordsProducedV2 {
    /// Creates a new `ReaderNumRecordsProducedV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ReaderNumRecordsProducedV2` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        reader_handle: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(reader_handle.into(), scope)
    }
    fn build_impl(
        &self,
        reader_handle: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ReaderNumRecordsProducedV2", |nd| {
            nd.add_input(reader_handle);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ReaderNumRecordsProducedV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        reader_handle: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ReaderNumRecordsProducedV2Inst> {
        let op = scope.new_operation("ReaderNumRecordsProducedV2", |builder| {
            builder.add_input(reader_handle);
            ::std::result::Result::Ok(())
        })?;
        Ok(ReaderNumRecordsProducedV2Inst { op })
    }
}
impl ReaderNumRecordsProducedV2Inst {
    /// Returns the 'records_produced' Output of this 'ReaderNumRecordsProducedV2' operation.
    pub fn records_produced(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'reader_handle' Input of this 'ReaderNumRecordsProducedV2' operation.
    pub fn reader_handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<ReaderNumRecordsProducedV2Inst> for crate::Operation {
    fn from(inst: ReaderNumRecordsProducedV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ReaderNumRecordsProducedV2::new().build(reader_handle, scope)`.
pub fn reader_num_records_produced_v2<O0: ::std::convert::Into<crate::Output>>(
    reader_handle: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ReaderNumRecordsProducedV2::new().build(reader_handle, scope)
}

/// Builder for the `ReaderNumWorkUnitsCompleted` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ReaderNumWorkUnitsCompleted {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ReaderNumWorkUnitsCompleted' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ReaderNumWorkUnitsCompletedInst {
    /// An instance of a fully built ReaderNumWorkUnitsCompleted Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ReaderNumWorkUnitsCompleted {
    /// Creates a new `ReaderNumWorkUnitsCompleted`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ReaderNumWorkUnitsCompleted` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        reader_handle: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(reader_handle.into(), scope)
    }
    fn build_impl(
        &self,
        reader_handle: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ReaderNumWorkUnitsCompleted", |nd| {
            nd.add_input(reader_handle);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ReaderNumWorkUnitsCompleted' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        reader_handle: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ReaderNumWorkUnitsCompletedInst> {
        let op = scope.new_operation("ReaderNumWorkUnitsCompleted", |builder| {
            builder.add_input(reader_handle);
            ::std::result::Result::Ok(())
        })?;
        Ok(ReaderNumWorkUnitsCompletedInst { op })
    }
}
impl ReaderNumWorkUnitsCompletedInst {
    /// Returns the 'units_completed' Output of this 'ReaderNumWorkUnitsCompleted' operation.
    pub fn units_completed(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'reader_handle' Input of this 'ReaderNumWorkUnitsCompleted' operation.
    pub fn reader_handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<ReaderNumWorkUnitsCompletedInst> for crate::Operation {
    fn from(inst: ReaderNumWorkUnitsCompletedInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ReaderNumWorkUnitsCompleted::new().build(reader_handle, scope)`.
pub fn reader_num_work_units_completed<O0: ::std::convert::Into<crate::Output>>(
    reader_handle: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ReaderNumWorkUnitsCompleted::new().build(reader_handle, scope)
}

/// Builder for the `ReaderNumWorkUnitsCompletedV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ReaderNumWorkUnitsCompletedV2 {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ReaderNumWorkUnitsCompletedV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ReaderNumWorkUnitsCompletedV2Inst {
    /// An instance of a fully built ReaderNumWorkUnitsCompletedV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ReaderNumWorkUnitsCompletedV2 {
    /// Creates a new `ReaderNumWorkUnitsCompletedV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ReaderNumWorkUnitsCompletedV2` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        reader_handle: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(reader_handle.into(), scope)
    }
    fn build_impl(
        &self,
        reader_handle: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ReaderNumWorkUnitsCompletedV2", |nd| {
            nd.add_input(reader_handle);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ReaderNumWorkUnitsCompletedV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        reader_handle: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ReaderNumWorkUnitsCompletedV2Inst> {
        let op = scope.new_operation("ReaderNumWorkUnitsCompletedV2", |builder| {
            builder.add_input(reader_handle);
            ::std::result::Result::Ok(())
        })?;
        Ok(ReaderNumWorkUnitsCompletedV2Inst { op })
    }
}
impl ReaderNumWorkUnitsCompletedV2Inst {
    /// Returns the 'units_completed' Output of this 'ReaderNumWorkUnitsCompletedV2' operation.
    pub fn units_completed(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'reader_handle' Input of this 'ReaderNumWorkUnitsCompletedV2' operation.
    pub fn reader_handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<ReaderNumWorkUnitsCompletedV2Inst> for crate::Operation {
    fn from(inst: ReaderNumWorkUnitsCompletedV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ReaderNumWorkUnitsCompletedV2::new().build(reader_handle, scope)`.
pub fn reader_num_work_units_completed_v2<O0: ::std::convert::Into<crate::Output>>(
    reader_handle: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ReaderNumWorkUnitsCompletedV2::new().build(reader_handle, scope)
}

/// Builder for the `ReaderRead` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ReaderRead {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ReaderRead' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ReaderReadInst {
    /// An instance of a fully built ReaderRead Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ReaderRead {
    /// Creates a new `ReaderRead`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ReaderRead` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        reader_handle: O0,
        queue_handle: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(reader_handle.into(), queue_handle.into(), scope)
    }
    fn build_impl(
        &self,
        reader_handle: crate::Output,
        queue_handle: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ReaderRead", |nd| {
            nd.add_input(reader_handle);
            nd.add_input(queue_handle);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ReaderRead' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        reader_handle: crate::Output,
        queue_handle: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ReaderReadInst> {
        let op = scope.new_operation("ReaderRead", |builder| {
            builder.add_input(reader_handle);
            builder.add_input(queue_handle);
            ::std::result::Result::Ok(())
        })?;
        Ok(ReaderReadInst { op })
    }
}
impl ReaderReadInst {
    /// Returns the 'key' Output of this 'ReaderRead' operation.
    pub fn key(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'value' Output of this 'ReaderRead' operation.
    pub fn value(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'reader_handle' Input of this 'ReaderRead' operation.
    pub fn reader_handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'queue_handle' Input of this 'ReaderRead' operation.
    pub fn queue_handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<ReaderReadInst> for crate::Operation {
    fn from(inst: ReaderReadInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ReaderRead::new().build(reader_handle, queue_handle, scope)`.
pub fn reader_read<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    reader_handle: O0,
    queue_handle: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ReaderRead::new().build(reader_handle, queue_handle, scope)
}

/// Builder for the `ReaderReadUpTo` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ReaderReadUpTo {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ReaderReadUpTo' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ReaderReadUpToInst {
    /// An instance of a fully built ReaderReadUpTo Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ReaderReadUpTo {
    /// Creates a new `ReaderReadUpTo`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ReaderReadUpTo` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        reader_handle: O0,
        queue_handle: O1,
        num_records: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            reader_handle.into(),
            queue_handle.into(),
            num_records.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        reader_handle: crate::Output,
        queue_handle: crate::Output,
        num_records: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ReaderReadUpTo", |nd| {
            nd.add_input(reader_handle);
            nd.add_input(queue_handle);
            nd.add_input(num_records);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ReaderReadUpTo' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        reader_handle: crate::Output,
        queue_handle: crate::Output,
        num_records: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ReaderReadUpToInst> {
        let op = scope.new_operation("ReaderReadUpTo", |builder| {
            builder.add_input(reader_handle);
            builder.add_input(queue_handle);
            builder.add_input(num_records);
            ::std::result::Result::Ok(())
        })?;
        Ok(ReaderReadUpToInst { op })
    }
}
impl ReaderReadUpToInst {
    /// Returns the 'keys' Output of this 'ReaderReadUpTo' operation.
    pub fn keys(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'values' Output of this 'ReaderReadUpTo' operation.
    pub fn values(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'reader_handle' Input of this 'ReaderReadUpTo' operation.
    pub fn reader_handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'queue_handle' Input of this 'ReaderReadUpTo' operation.
    pub fn queue_handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'num_records' Input of this 'ReaderReadUpTo' operation.
    pub fn num_records(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<ReaderReadUpToInst> for crate::Operation {
    fn from(inst: ReaderReadUpToInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ReaderReadUpTo::new().build(reader_handle, queue_handle, num_records, scope)`.
pub fn reader_read_up_to<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    reader_handle: O0,
    queue_handle: O1,
    num_records: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ReaderReadUpTo::new().build(reader_handle, queue_handle, num_records, scope)
}

/// Builder for the `ReaderReadUpToV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ReaderReadUpToV2 {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ReaderReadUpToV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ReaderReadUpToV2Inst {
    /// An instance of a fully built ReaderReadUpToV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ReaderReadUpToV2 {
    /// Creates a new `ReaderReadUpToV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ReaderReadUpToV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        reader_handle: O0,
        queue_handle: O1,
        num_records: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            reader_handle.into(),
            queue_handle.into(),
            num_records.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        reader_handle: crate::Output,
        queue_handle: crate::Output,
        num_records: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ReaderReadUpToV2", |nd| {
            nd.add_input(reader_handle);
            nd.add_input(queue_handle);
            nd.add_input(num_records);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ReaderReadUpToV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        reader_handle: crate::Output,
        queue_handle: crate::Output,
        num_records: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ReaderReadUpToV2Inst> {
        let op = scope.new_operation("ReaderReadUpToV2", |builder| {
            builder.add_input(reader_handle);
            builder.add_input(queue_handle);
            builder.add_input(num_records);
            ::std::result::Result::Ok(())
        })?;
        Ok(ReaderReadUpToV2Inst { op })
    }
}
impl ReaderReadUpToV2Inst {
    /// Returns the 'keys' Output of this 'ReaderReadUpToV2' operation.
    pub fn keys(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'values' Output of this 'ReaderReadUpToV2' operation.
    pub fn values(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'reader_handle' Input of this 'ReaderReadUpToV2' operation.
    pub fn reader_handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'queue_handle' Input of this 'ReaderReadUpToV2' operation.
    pub fn queue_handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'num_records' Input of this 'ReaderReadUpToV2' operation.
    pub fn num_records(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<ReaderReadUpToV2Inst> for crate::Operation {
    fn from(inst: ReaderReadUpToV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ReaderReadUpToV2::new().build(reader_handle, queue_handle, num_records, scope)`.
pub fn reader_read_up_to_v2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    reader_handle: O0,
    queue_handle: O1,
    num_records: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ReaderReadUpToV2::new().build(reader_handle, queue_handle, num_records, scope)
}

/// Builder for the `ReaderReadV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ReaderReadV2 {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ReaderReadV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ReaderReadV2Inst {
    /// An instance of a fully built ReaderReadV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ReaderReadV2 {
    /// Creates a new `ReaderReadV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ReaderReadV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        reader_handle: O0,
        queue_handle: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(reader_handle.into(), queue_handle.into(), scope)
    }
    fn build_impl(
        &self,
        reader_handle: crate::Output,
        queue_handle: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ReaderReadV2", |nd| {
            nd.add_input(reader_handle);
            nd.add_input(queue_handle);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ReaderReadV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        reader_handle: crate::Output,
        queue_handle: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ReaderReadV2Inst> {
        let op = scope.new_operation("ReaderReadV2", |builder| {
            builder.add_input(reader_handle);
            builder.add_input(queue_handle);
            ::std::result::Result::Ok(())
        })?;
        Ok(ReaderReadV2Inst { op })
    }
}
impl ReaderReadV2Inst {
    /// Returns the 'key' Output of this 'ReaderReadV2' operation.
    pub fn key(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'value' Output of this 'ReaderReadV2' operation.
    pub fn value(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'reader_handle' Input of this 'ReaderReadV2' operation.
    pub fn reader_handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'queue_handle' Input of this 'ReaderReadV2' operation.
    pub fn queue_handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<ReaderReadV2Inst> for crate::Operation {
    fn from(inst: ReaderReadV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ReaderReadV2::new().build(reader_handle, queue_handle, scope)`.
pub fn reader_read_v2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    reader_handle: O0,
    queue_handle: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ReaderReadV2::new().build(reader_handle, queue_handle, scope)
}

/// Builder for the `ReaderReset` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ReaderReset {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ReaderReset' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ReaderResetInst {
    /// An instance of a fully built ReaderReset Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ReaderReset {
    /// Creates a new `ReaderReset`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ReaderReset` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        reader_handle: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(reader_handle.into(), scope)
    }
    fn build_impl(
        &self,
        reader_handle: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ReaderReset", |nd| {
            nd.add_input(reader_handle);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ReaderReset' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        reader_handle: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ReaderResetInst> {
        let op = scope.new_operation("ReaderReset", |builder| {
            builder.add_input(reader_handle);
            ::std::result::Result::Ok(())
        })?;
        Ok(ReaderResetInst { op })
    }
}
impl ReaderResetInst {
    /// Returns the 'reader_handle' Input of this 'ReaderReset' operation.
    pub fn reader_handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<ReaderResetInst> for crate::Operation {
    fn from(inst: ReaderResetInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ReaderReset::new().build(reader_handle, scope)`.
pub fn reader_reset<O0: ::std::convert::Into<crate::Output>>(
    reader_handle: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ReaderReset::new().build(reader_handle, scope)
}

/// Builder for the `ReaderResetV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ReaderResetV2 {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ReaderResetV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ReaderResetV2Inst {
    /// An instance of a fully built ReaderResetV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ReaderResetV2 {
    /// Creates a new `ReaderResetV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ReaderResetV2` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        reader_handle: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(reader_handle.into(), scope)
    }
    fn build_impl(
        &self,
        reader_handle: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ReaderResetV2", |nd| {
            nd.add_input(reader_handle);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ReaderResetV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        reader_handle: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ReaderResetV2Inst> {
        let op = scope.new_operation("ReaderResetV2", |builder| {
            builder.add_input(reader_handle);
            ::std::result::Result::Ok(())
        })?;
        Ok(ReaderResetV2Inst { op })
    }
}
impl ReaderResetV2Inst {
    /// Returns the 'reader_handle' Input of this 'ReaderResetV2' operation.
    pub fn reader_handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<ReaderResetV2Inst> for crate::Operation {
    fn from(inst: ReaderResetV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ReaderResetV2::new().build(reader_handle, scope)`.
pub fn reader_reset_v2<O0: ::std::convert::Into<crate::Output>>(
    reader_handle: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ReaderResetV2::new().build(reader_handle, scope)
}

/// Builder for the `ReaderRestoreState` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ReaderRestoreState {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ReaderRestoreState' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ReaderRestoreStateInst {
    /// An instance of a fully built ReaderRestoreState Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ReaderRestoreState {
    /// Creates a new `ReaderRestoreState`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ReaderRestoreState` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        reader_handle: O0,
        state: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(reader_handle.into(), state.into(), scope)
    }
    fn build_impl(
        &self,
        reader_handle: crate::Output,
        state: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ReaderRestoreState", |nd| {
            nd.add_input(reader_handle);
            nd.add_input(state);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ReaderRestoreState' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        reader_handle: crate::Output,
        state: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ReaderRestoreStateInst> {
        let op = scope.new_operation("ReaderRestoreState", |builder| {
            builder.add_input(reader_handle);
            builder.add_input(state);
            ::std::result::Result::Ok(())
        })?;
        Ok(ReaderRestoreStateInst { op })
    }
}
impl ReaderRestoreStateInst {
    /// Returns the 'reader_handle' Input of this 'ReaderRestoreState' operation.
    pub fn reader_handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'state' Input of this 'ReaderRestoreState' operation.
    pub fn state(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<ReaderRestoreStateInst> for crate::Operation {
    fn from(inst: ReaderRestoreStateInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ReaderRestoreState::new().build(reader_handle, state, scope)`.
pub fn reader_restore_state<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    reader_handle: O0,
    state: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ReaderRestoreState::new().build(reader_handle, state, scope)
}

/// Builder for the `ReaderRestoreStateV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ReaderRestoreStateV2 {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ReaderRestoreStateV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ReaderRestoreStateV2Inst {
    /// An instance of a fully built ReaderRestoreStateV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ReaderRestoreStateV2 {
    /// Creates a new `ReaderRestoreStateV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ReaderRestoreStateV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        reader_handle: O0,
        state: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(reader_handle.into(), state.into(), scope)
    }
    fn build_impl(
        &self,
        reader_handle: crate::Output,
        state: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ReaderRestoreStateV2", |nd| {
            nd.add_input(reader_handle);
            nd.add_input(state);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ReaderRestoreStateV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        reader_handle: crate::Output,
        state: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ReaderRestoreStateV2Inst> {
        let op = scope.new_operation("ReaderRestoreStateV2", |builder| {
            builder.add_input(reader_handle);
            builder.add_input(state);
            ::std::result::Result::Ok(())
        })?;
        Ok(ReaderRestoreStateV2Inst { op })
    }
}
impl ReaderRestoreStateV2Inst {
    /// Returns the 'reader_handle' Input of this 'ReaderRestoreStateV2' operation.
    pub fn reader_handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'state' Input of this 'ReaderRestoreStateV2' operation.
    pub fn state(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<ReaderRestoreStateV2Inst> for crate::Operation {
    fn from(inst: ReaderRestoreStateV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ReaderRestoreStateV2::new().build(reader_handle, state, scope)`.
pub fn reader_restore_state_v2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    reader_handle: O0,
    state: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ReaderRestoreStateV2::new().build(reader_handle, state, scope)
}

/// Builder for the `ReaderSerializeState` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ReaderSerializeState {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ReaderSerializeState' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ReaderSerializeStateInst {
    /// An instance of a fully built ReaderSerializeState Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ReaderSerializeState {
    /// Creates a new `ReaderSerializeState`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ReaderSerializeState` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        reader_handle: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(reader_handle.into(), scope)
    }
    fn build_impl(
        &self,
        reader_handle: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ReaderSerializeState", |nd| {
            nd.add_input(reader_handle);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ReaderSerializeState' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        reader_handle: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ReaderSerializeStateInst> {
        let op = scope.new_operation("ReaderSerializeState", |builder| {
            builder.add_input(reader_handle);
            ::std::result::Result::Ok(())
        })?;
        Ok(ReaderSerializeStateInst { op })
    }
}
impl ReaderSerializeStateInst {
    /// Returns the 'state' Output of this 'ReaderSerializeState' operation.
    pub fn state(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'reader_handle' Input of this 'ReaderSerializeState' operation.
    pub fn reader_handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<ReaderSerializeStateInst> for crate::Operation {
    fn from(inst: ReaderSerializeStateInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ReaderSerializeState::new().build(reader_handle, scope)`.
pub fn reader_serialize_state<O0: ::std::convert::Into<crate::Output>>(
    reader_handle: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ReaderSerializeState::new().build(reader_handle, scope)
}

/// Builder for the `ReaderSerializeStateV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ReaderSerializeStateV2 {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ReaderSerializeStateV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ReaderSerializeStateV2Inst {
    /// An instance of a fully built ReaderSerializeStateV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ReaderSerializeStateV2 {
    /// Creates a new `ReaderSerializeStateV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ReaderSerializeStateV2` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        reader_handle: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(reader_handle.into(), scope)
    }
    fn build_impl(
        &self,
        reader_handle: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ReaderSerializeStateV2", |nd| {
            nd.add_input(reader_handle);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ReaderSerializeStateV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        reader_handle: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ReaderSerializeStateV2Inst> {
        let op = scope.new_operation("ReaderSerializeStateV2", |builder| {
            builder.add_input(reader_handle);
            ::std::result::Result::Ok(())
        })?;
        Ok(ReaderSerializeStateV2Inst { op })
    }
}
impl ReaderSerializeStateV2Inst {
    /// Returns the 'state' Output of this 'ReaderSerializeStateV2' operation.
    pub fn state(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'reader_handle' Input of this 'ReaderSerializeStateV2' operation.
    pub fn reader_handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<ReaderSerializeStateV2Inst> for crate::Operation {
    fn from(inst: ReaderSerializeStateV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ReaderSerializeStateV2::new().build(reader_handle, scope)`.
pub fn reader_serialize_state_v2<O0: ::std::convert::Into<crate::Output>>(
    reader_handle: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ReaderSerializeStateV2::new().build(reader_handle, scope)
}

/// Builder for the `Real` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Real {
    T: ::std::option::Option<crate::DataType>,
    Tout: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Real' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RealInst {
    /// An instance of a fully built Real Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Real {
    /// Creates a new `Real`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tout` attribute.
    pub fn Tout<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Tout = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Real` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Real", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tout {
                nd.set_attr_type("Tout", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Real' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<RealInst> {
        let op = scope.new_operation("Real", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tout {
                builder.set_attr_type("Tout", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RealInst { op })
    }
}
impl RealInst {
    /// Returns the 'output' Output of this 'Real' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'Real' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<RealInst> for crate::Operation {
    fn from(inst: RealInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Real::new().build(input, scope)`.
pub fn real<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Real::new().build(input, scope)
}

/// Builder for the `RealDiv` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RealDiv {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RealDiv' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RealDivInst {
    /// An instance of a fully built RealDiv Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RealDiv {
    /// Creates a new `RealDiv`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RealDiv` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        x: O0,
        y: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), y.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        y: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("RealDiv", |nd| {
            nd.add_input(x);
            nd.add_input(y);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RealDiv' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        y: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<RealDivInst> {
        let op = scope.new_operation("RealDiv", |builder| {
            builder.add_input(x);
            builder.add_input(y);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RealDivInst { op })
    }
}
impl RealDivInst {
    /// Returns the 'z' Output of this 'RealDiv' operation.
    pub fn z(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'RealDiv' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'y' Input of this 'RealDiv' operation.
    pub fn y(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<RealDivInst> for crate::Operation {
    fn from(inst: RealDivInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RealDiv::new().build(x, y, scope)`.
pub fn real_div<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    x: O0,
    y: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RealDiv::new().build(x, y, scope)
}

/// Builder for the `RebatchDataset` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RebatchDataset {
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    use_fallback: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RebatchDataset' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RebatchDatasetInst {
    /// An instance of a fully built RebatchDataset Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RebatchDataset {
    /// Creates a new `RebatchDataset`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_fallback` attribute.
    pub fn use_fallback<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.use_fallback = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RebatchDataset` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input_dataset: O0,
        num_replicas: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input_dataset.into(), num_replicas.into(), scope)
    }
    fn build_impl(
        &self,
        input_dataset: crate::Output,
        num_replicas: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("RebatchDataset", |nd| {
            nd.add_input(input_dataset);
            nd.add_input(num_replicas);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_fallback {
                nd.set_attr_bool("use_fallback", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RebatchDataset' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_dataset: crate::Output,
        num_replicas: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<RebatchDatasetInst> {
        let op = scope.new_operation("RebatchDataset", |builder| {
            builder.add_input(input_dataset);
            builder.add_input(num_replicas);
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_fallback {
                builder.set_attr_bool("use_fallback", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RebatchDatasetInst { op })
    }
}
impl RebatchDatasetInst {
    /// Returns the 'handle' Output of this 'RebatchDataset' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_dataset' Input of this 'RebatchDataset' operation.
    pub fn input_dataset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'num_replicas' Input of this 'RebatchDataset' operation.
    pub fn num_replicas(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<RebatchDatasetInst> for crate::Operation {
    fn from(inst: RebatchDatasetInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RebatchDataset::new().build(input_dataset, num_replicas, scope)`.
pub fn rebatch_dataset<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    input_dataset: O0,
    num_replicas: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RebatchDataset::new().build(input_dataset, num_replicas, scope)
}

/// Builder for the `RebatchDatasetV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RebatchDatasetV2 {
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RebatchDatasetV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RebatchDatasetV2Inst {
    /// An instance of a fully built RebatchDatasetV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RebatchDatasetV2 {
    /// Creates a new `RebatchDatasetV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RebatchDatasetV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input_dataset: O0,
        batch_sizes: O1,
        drop_remainder: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            input_dataset.into(),
            batch_sizes.into(),
            drop_remainder.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        input_dataset: crate::Output,
        batch_sizes: crate::Output,
        drop_remainder: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("RebatchDatasetV2", |nd| {
            nd.add_input(input_dataset);
            nd.add_input(batch_sizes);
            nd.add_input(drop_remainder);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RebatchDatasetV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_dataset: crate::Output,
        batch_sizes: crate::Output,
        drop_remainder: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<RebatchDatasetV2Inst> {
        let op = scope.new_operation("RebatchDatasetV2", |builder| {
            builder.add_input(input_dataset);
            builder.add_input(batch_sizes);
            builder.add_input(drop_remainder);
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RebatchDatasetV2Inst { op })
    }
}
impl RebatchDatasetV2Inst {
    /// Returns the 'handle' Output of this 'RebatchDatasetV2' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_dataset' Input of this 'RebatchDatasetV2' operation.
    pub fn input_dataset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'batch_sizes' Input of this 'RebatchDatasetV2' operation.
    pub fn batch_sizes(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'drop_remainder' Input of this 'RebatchDatasetV2' operation.
    pub fn drop_remainder(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<RebatchDatasetV2Inst> for crate::Operation {
    fn from(inst: RebatchDatasetV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RebatchDatasetV2::new().build(input_dataset, batch_sizes, drop_remainder, scope)`.
pub fn rebatch_dataset_v2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    input_dataset: O0,
    batch_sizes: O1,
    drop_remainder: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RebatchDatasetV2::new().build(input_dataset, batch_sizes, drop_remainder, scope)
}

/// Builder for the `Reciprocal` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Reciprocal {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Reciprocal' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ReciprocalInst {
    /// An instance of a fully built Reciprocal Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Reciprocal {
    /// Creates a new `Reciprocal`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Reciprocal` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        x: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Reciprocal", |nd| {
            nd.add_input(x);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Reciprocal' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ReciprocalInst> {
        let op = scope.new_operation("Reciprocal", |builder| {
            builder.add_input(x);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ReciprocalInst { op })
    }
}
impl ReciprocalInst {
    /// Returns the 'y' Output of this 'Reciprocal' operation.
    pub fn y(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'Reciprocal' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<ReciprocalInst> for crate::Operation {
    fn from(inst: ReciprocalInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Reciprocal::new().build(x, scope)`.
pub fn reciprocal<O0: ::std::convert::Into<crate::Output>>(
    x: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Reciprocal::new().build(x, scope)
}

/// Builder for the `ReciprocalGrad` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ReciprocalGrad {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ReciprocalGrad' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ReciprocalGradInst {
    /// An instance of a fully built ReciprocalGrad Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ReciprocalGrad {
    /// Creates a new `ReciprocalGrad`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ReciprocalGrad` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        y: O0,
        dy: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(y.into(), dy.into(), scope)
    }
    fn build_impl(
        &self,
        y: crate::Output,
        dy: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ReciprocalGrad", |nd| {
            nd.add_input(y);
            nd.add_input(dy);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ReciprocalGrad' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        y: crate::Output,
        dy: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ReciprocalGradInst> {
        let op = scope.new_operation("ReciprocalGrad", |builder| {
            builder.add_input(y);
            builder.add_input(dy);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ReciprocalGradInst { op })
    }
}
impl ReciprocalGradInst {
    /// Returns the 'z' Output of this 'ReciprocalGrad' operation.
    pub fn z(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'y' Input of this 'ReciprocalGrad' operation.
    pub fn y(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'dy' Input of this 'ReciprocalGrad' operation.
    pub fn dy(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<ReciprocalGradInst> for crate::Operation {
    fn from(inst: ReciprocalGradInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ReciprocalGrad::new().build(y, dy, scope)`.
pub fn reciprocal_grad<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    y: O0,
    dy: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ReciprocalGrad::new().build(y, dy, scope)
}

/// Builder for the `RecordInput` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RecordInput {
    file_pattern: ::std::option::Option<::std::string::String>,
    file_random_seed: ::std::option::Option<i64>,
    file_shuffle_shift_ratio: ::std::option::Option<f32>,
    file_buffer_size: ::std::option::Option<i64>,
    file_parallelism: ::std::option::Option<i64>,
    batch_size: ::std::option::Option<i64>,
    compression_type: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RecordInput' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RecordInputInst {
    /// An instance of a fully built RecordInput Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RecordInput {
    /// Creates a new `RecordInput`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `file_pattern` attribute.
    pub fn file_pattern<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.file_pattern = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `file_random_seed` attribute.
    pub fn file_random_seed<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.file_random_seed = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `file_shuffle_shift_ratio` attribute.
    pub fn file_shuffle_shift_ratio<ArgType: ::std::convert::Into<f32>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.file_shuffle_shift_ratio = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `file_buffer_size` attribute.
    pub fn file_buffer_size<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.file_buffer_size = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `file_parallelism` attribute.
    pub fn file_parallelism<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.file_parallelism = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `batch_size` attribute.
    pub fn batch_size<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.batch_size = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `compression_type` attribute.
    pub fn compression_type<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.compression_type = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RecordInput` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("RecordInput", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.file_pattern {
                nd.set_attr_string("file_pattern", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.file_random_seed {
                nd.set_attr_int("file_random_seed", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.file_shuffle_shift_ratio {
                nd.set_attr_float("file_shuffle_shift_ratio", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.file_buffer_size {
                nd.set_attr_int("file_buffer_size", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.file_parallelism {
                nd.set_attr_int("file_parallelism", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.batch_size {
                nd.set_attr_int("batch_size", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.compression_type {
                nd.set_attr_string("compression_type", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RecordInput' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(&self, scope: &mut crate::Scope) -> crate::Result<RecordInputInst> {
        let op = scope.new_operation("RecordInput", |builder| {
            if let ::std::option::Option::Some(value) = &self.file_pattern {
                builder.set_attr_string("file_pattern", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.file_random_seed {
                builder.set_attr_int("file_random_seed", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.file_shuffle_shift_ratio {
                builder.set_attr_float("file_shuffle_shift_ratio", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.file_buffer_size {
                builder.set_attr_int("file_buffer_size", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.file_parallelism {
                builder.set_attr_int("file_parallelism", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.batch_size {
                builder.set_attr_int("batch_size", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.compression_type {
                builder.set_attr_string("compression_type", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RecordInputInst { op })
    }
}
impl RecordInputInst {
    /// Returns the 'records' Output of this 'RecordInput' operation.
    pub fn records(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
}
impl From<RecordInputInst> for crate::Operation {
    fn from(inst: RecordInputInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RecordInput::new().build(scope)`.
pub fn record_input(scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
    RecordInput::new().build(scope)
}

/// Builder for the `Recv` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Recv {
    tensor_type: ::std::option::Option<crate::DataType>,
    tensor_name: ::std::option::Option<::std::string::String>,
    send_device: ::std::option::Option<::std::string::String>,
    send_device_incarnation: ::std::option::Option<i64>,
    recv_device: ::std::option::Option<::std::string::String>,
    client_terminated: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Recv' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RecvInst {
    /// An instance of a fully built Recv Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Recv {
    /// Creates a new `Recv`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `tensor_type` attribute.
    pub fn tensor_type<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.tensor_type = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `tensor_name` attribute.
    pub fn tensor_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.tensor_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `send_device` attribute.
    pub fn send_device<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.send_device = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `send_device_incarnation` attribute.
    pub fn send_device_incarnation<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.send_device_incarnation = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `recv_device` attribute.
    pub fn recv_device<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.recv_device = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `client_terminated` attribute.
    pub fn client_terminated<ArgType: ::std::convert::Into<bool>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.client_terminated = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Recv` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("Recv", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.tensor_type {
                nd.set_attr_type("tensor_type", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.tensor_name {
                nd.set_attr_string("tensor_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.send_device {
                nd.set_attr_string("send_device", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.send_device_incarnation {
                nd.set_attr_int("send_device_incarnation", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.recv_device {
                nd.set_attr_string("recv_device", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.client_terminated {
                nd.set_attr_bool("client_terminated", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Recv' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(&self, scope: &mut crate::Scope) -> crate::Result<RecvInst> {
        let op = scope.new_operation("Recv", |builder| {
            if let ::std::option::Option::Some(value) = &self.tensor_type {
                builder.set_attr_type("tensor_type", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.tensor_name {
                builder.set_attr_string("tensor_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.send_device {
                builder.set_attr_string("send_device", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.send_device_incarnation {
                builder.set_attr_int("send_device_incarnation", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.recv_device {
                builder.set_attr_string("recv_device", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.client_terminated {
                builder.set_attr_bool("client_terminated", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RecvInst { op })
    }
}
impl RecvInst {
    /// Returns the 'tensor' Output of this 'Recv' operation.
    pub fn tensor(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
}
impl From<RecvInst> for crate::Operation {
    fn from(inst: RecvInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Recv::new().build(scope)`.
pub fn recv(scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
    Recv::new().build(scope)
}

/// Builder for the `RecvTPUEmbeddingActivations` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RecvTPUEmbeddingActivations {
    num_outputs: ::std::option::Option<i64>,
    config: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RecvTPUEmbeddingActivations' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RecvTPUEmbeddingActivationsInst {
    /// An instance of a fully built RecvTPUEmbeddingActivations Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RecvTPUEmbeddingActivations {
    /// Creates a new `RecvTPUEmbeddingActivations`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `num_outputs` attribute.
    pub fn num_outputs<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.num_outputs = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `config` attribute.
    pub fn config<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.config = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RecvTPUEmbeddingActivations` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("RecvTPUEmbeddingActivations", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.num_outputs {
                nd.set_attr_int("num_outputs", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.config {
                nd.set_attr_string("config", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RecvTPUEmbeddingActivations' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        scope: &mut crate::Scope,
    ) -> crate::Result<RecvTPUEmbeddingActivationsInst> {
        let op = scope.new_operation("RecvTPUEmbeddingActivations", |builder| {
            if let ::std::option::Option::Some(value) = &self.num_outputs {
                builder.set_attr_int("num_outputs", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.config {
                builder.set_attr_string("config", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RecvTPUEmbeddingActivationsInst { op })
    }
}
impl RecvTPUEmbeddingActivationsInst {
    /// Returns a Vector of outputs for 'outputs' Output of this RecvTPUEmbeddingActivations operation.
    pub fn outputs(&self) -> crate::Result<Vec<crate::Output>> {
        let mut Outputs = vec![];
        for i in 0..self.op.get_attr_int("num_outputs")? as i32 {
            Outputs.push(crate::Output {
                operation: self.op.clone(),
                index: i,
            });
        }
        Ok(Outputs)
    }
}
impl From<RecvTPUEmbeddingActivationsInst> for crate::Operation {
    fn from(inst: RecvTPUEmbeddingActivationsInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RecvTPUEmbeddingActivations::new().build(scope)`.
pub fn recv_tpuembedding_activations(scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
    RecvTPUEmbeddingActivations::new().build(scope)
}

/// Builder for the `ReduceDataset` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ReduceDataset {
    f: ::std::option::Option<::std::string::String>,
    Tstate: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    Targuments: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    use_inter_op_parallelism: ::std::option::Option<bool>,
    metadata: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ReduceDataset' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ReduceDatasetInst {
    /// An instance of a fully built ReduceDataset Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ReduceDataset {
    /// Creates a new `ReduceDataset`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `f` attribute.
    pub fn f<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.f = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tstate` attribute.
    pub fn Tstate<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tstate = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Targuments` attribute.
    pub fn Targuments<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Targuments = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_inter_op_parallelism` attribute.
    pub fn use_inter_op_parallelism<ArgType: ::std::convert::Into<bool>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.use_inter_op_parallelism = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `metadata` attribute.
    pub fn metadata<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.metadata = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ReduceDataset` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input_dataset: O0,
        initial_state: O1,
        other_arguments: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            input_dataset.into(),
            initial_state.into(),
            other_arguments.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        input_dataset: crate::Output,
        initial_state: crate::Output,
        other_arguments: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ReduceDataset", |nd| {
            nd.add_input(input_dataset);
            nd.add_input(initial_state);
            nd.add_input(other_arguments);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.f {
                nd.set_attr_string("f", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tstate {
                nd.set_attr_type_list("Tstate", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Targuments {
                nd.set_attr_type_list("Targuments", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_inter_op_parallelism {
                nd.set_attr_bool("use_inter_op_parallelism", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.metadata {
                nd.set_attr_string("metadata", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ReduceDataset' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_dataset: crate::Output,
        initial_state: crate::Output,
        other_arguments: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ReduceDatasetInst> {
        let op = scope.new_operation("ReduceDataset", |builder| {
            builder.add_input(input_dataset);
            builder.add_input(initial_state);
            builder.add_input(other_arguments);
            if let ::std::option::Option::Some(value) = &self.f {
                builder.set_attr_string("f", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tstate {
                builder.set_attr_type_list("Tstate", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Targuments {
                builder.set_attr_type_list("Targuments", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_inter_op_parallelism {
                builder.set_attr_bool("use_inter_op_parallelism", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.metadata {
                builder.set_attr_string("metadata", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ReduceDatasetInst { op })
    }
}
impl ReduceDatasetInst {
    /// Returns the 'components' Output of this 'ReduceDataset' operation.
    pub fn components(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_dataset' Input of this 'ReduceDataset' operation.
    pub fn input_dataset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'initial_state' Input of this 'ReduceDataset' operation.
    pub fn initial_state(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'other_arguments' Input of this 'ReduceDataset' operation.
    pub fn other_arguments(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<ReduceDatasetInst> for crate::Operation {
    fn from(inst: ReduceDatasetInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ReduceDataset::new().build(input_dataset, initial_state, other_arguments, scope)`.
pub fn reduce_dataset<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    input_dataset: O0,
    initial_state: O1,
    other_arguments: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ReduceDataset::new().build(input_dataset, initial_state, other_arguments, scope)
}

/// Builder for the `ReduceJoin` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ReduceJoin {
    keep_dims: ::std::option::Option<bool>,
    separator: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ReduceJoin' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ReduceJoinInst {
    /// An instance of a fully built ReduceJoin Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ReduceJoin {
    /// Creates a new `ReduceJoin`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `keep_dims` attribute.
    pub fn keep_dims<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.keep_dims = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `separator` attribute.
    pub fn separator<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.separator = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ReduceJoin` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        inputs: O0,
        reduction_indices: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(inputs.into(), reduction_indices.into(), scope)
    }
    fn build_impl(
        &self,
        inputs: crate::Output,
        reduction_indices: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ReduceJoin", |nd| {
            nd.add_input(inputs);
            nd.add_input(reduction_indices);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.keep_dims {
                nd.set_attr_bool("keep_dims", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.separator {
                nd.set_attr_string("separator", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ReduceJoin' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        inputs: crate::Output,
        reduction_indices: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ReduceJoinInst> {
        let op = scope.new_operation("ReduceJoin", |builder| {
            builder.add_input(inputs);
            builder.add_input(reduction_indices);
            if let ::std::option::Option::Some(value) = &self.keep_dims {
                builder.set_attr_bool("keep_dims", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.separator {
                builder.set_attr_string("separator", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ReduceJoinInst { op })
    }
}
impl ReduceJoinInst {
    /// Returns the 'output' Output of this 'ReduceJoin' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'inputs' Input of this 'ReduceJoin' operation.
    pub fn inputs(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'reduction_indices' Input of this 'ReduceJoin' operation.
    pub fn reduction_indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<ReduceJoinInst> for crate::Operation {
    fn from(inst: ReduceJoinInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ReduceJoin::new().build(inputs, reduction_indices, scope)`.
pub fn reduce_join<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    inputs: O0,
    reduction_indices: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ReduceJoin::new().build(inputs, reduction_indices, scope)
}

/// Builder for the `RefEnter` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RefEnter {
    T: ::std::option::Option<crate::DataType>,
    frame_name: ::std::option::Option<::std::string::String>,
    is_constant: ::std::option::Option<bool>,
    parallel_iterations: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RefEnter' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RefEnterInst {
    /// An instance of a fully built RefEnter Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RefEnter {
    /// Creates a new `RefEnter`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `frame_name` attribute.
    pub fn frame_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.frame_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `is_constant` attribute.
    pub fn is_constant<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.is_constant = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `parallel_iterations` attribute.
    pub fn parallel_iterations<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.parallel_iterations = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RefEnter` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        data: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(data.into(), scope)
    }
    fn build_impl(
        &self,
        data: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("RefEnter", |nd| {
            nd.add_input(data);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.frame_name {
                nd.set_attr_string("frame_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.is_constant {
                nd.set_attr_bool("is_constant", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.parallel_iterations {
                nd.set_attr_int("parallel_iterations", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RefEnter' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        data: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<RefEnterInst> {
        let op = scope.new_operation("RefEnter", |builder| {
            builder.add_input(data);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.frame_name {
                builder.set_attr_string("frame_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.is_constant {
                builder.set_attr_bool("is_constant", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.parallel_iterations {
                builder.set_attr_int("parallel_iterations", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RefEnterInst { op })
    }
}
impl RefEnterInst {
    /// Returns the 'output' Output of this 'RefEnter' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'data' Input of this 'RefEnter' operation.
    pub fn data(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<RefEnterInst> for crate::Operation {
    fn from(inst: RefEnterInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RefEnter::new().build(data, scope)`.
pub fn ref_enter<O0: ::std::convert::Into<crate::Output>>(
    data: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RefEnter::new().build(data, scope)
}

/// Builder for the `RefExit` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RefExit {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RefExit' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RefExitInst {
    /// An instance of a fully built RefExit Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RefExit {
    /// Creates a new `RefExit`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RefExit` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        data: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(data.into(), scope)
    }
    fn build_impl(
        &self,
        data: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("RefExit", |nd| {
            nd.add_input(data);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RefExit' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        data: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<RefExitInst> {
        let op = scope.new_operation("RefExit", |builder| {
            builder.add_input(data);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RefExitInst { op })
    }
}
impl RefExitInst {
    /// Returns the 'output' Output of this 'RefExit' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'data' Input of this 'RefExit' operation.
    pub fn data(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<RefExitInst> for crate::Operation {
    fn from(inst: RefExitInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RefExit::new().build(data, scope)`.
pub fn ref_exit<O0: ::std::convert::Into<crate::Output>>(
    data: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RefExit::new().build(data, scope)
}

/// Builder for the `RefIdentity` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RefIdentity {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RefIdentity' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RefIdentityInst {
    /// An instance of a fully built RefIdentity Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RefIdentity {
    /// Creates a new `RefIdentity`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RefIdentity` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("RefIdentity", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RefIdentity' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<RefIdentityInst> {
        let op = scope.new_operation("RefIdentity", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RefIdentityInst { op })
    }
}
impl RefIdentityInst {
    /// Returns the 'output' Output of this 'RefIdentity' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'RefIdentity' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<RefIdentityInst> for crate::Operation {
    fn from(inst: RefIdentityInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RefIdentity::new().build(input, scope)`.
pub fn ref_identity<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RefIdentity::new().build(input, scope)
}

/// Builder for the `RefMerge` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RefMerge {
    T: ::std::option::Option<crate::DataType>,
    N: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RefMerge' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RefMergeInst {
    /// An instance of a fully built RefMerge Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RefMerge {
    /// Creates a new `RefMerge`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `N` attribute.
    pub fn N<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.N = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RefMerge` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        inputs: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(inputs.into(), scope)
    }
    fn build_impl(
        &self,
        inputs: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("RefMerge", |nd| {
            nd.add_input(inputs);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.N {
                nd.set_attr_int("N", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RefMerge' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        inputs: Vec<crate::Output>,
        scope: &mut crate::Scope,
    ) -> crate::Result<RefMergeInst> {
        let op = scope.new_operation("RefMerge", |builder| {
            builder.add_input_list(&inputs);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            builder.set_attr_int("N", inputs.clone().len() as i64)?;
            ::std::result::Result::Ok(())
        })?;
        Ok(RefMergeInst { op })
    }
}
impl RefMergeInst {
    /// Returns the 'output' Output of this 'RefMerge' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'value_index' Output of this 'RefMerge' operation.
    pub fn value_index(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns a Vector of inputs for 'inputs' Input of this RefMerge operation.
    pub fn inputs(&self) -> crate::Result<Vec<crate::Input>> {
        let mut Inputs = vec![];
        for i in 0..self.op.get_attr_int("N")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
}
impl From<RefMergeInst> for crate::Operation {
    fn from(inst: RefMergeInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RefMerge::new().build(inputs, scope)`.
pub fn ref_merge<O0: ::std::convert::Into<crate::Output>>(
    inputs: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RefMerge::new().build(inputs, scope)
}

/// Builder for the `RefNextIteration` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RefNextIteration {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RefNextIteration' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RefNextIterationInst {
    /// An instance of a fully built RefNextIteration Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RefNextIteration {
    /// Creates a new `RefNextIteration`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RefNextIteration` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        data: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(data.into(), scope)
    }
    fn build_impl(
        &self,
        data: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("RefNextIteration", |nd| {
            nd.add_input(data);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RefNextIteration' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        data: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<RefNextIterationInst> {
        let op = scope.new_operation("RefNextIteration", |builder| {
            builder.add_input(data);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RefNextIterationInst { op })
    }
}
impl RefNextIterationInst {
    /// Returns the 'output' Output of this 'RefNextIteration' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'data' Input of this 'RefNextIteration' operation.
    pub fn data(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<RefNextIterationInst> for crate::Operation {
    fn from(inst: RefNextIterationInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RefNextIteration::new().build(data, scope)`.
pub fn ref_next_iteration<O0: ::std::convert::Into<crate::Output>>(
    data: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RefNextIteration::new().build(data, scope)
}

/// Builder for the `RefSelect` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RefSelect {
    T: ::std::option::Option<crate::DataType>,
    N: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RefSelect' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RefSelectInst {
    /// An instance of a fully built RefSelect Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RefSelect {
    /// Creates a new `RefSelect`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `N` attribute.
    pub fn N<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.N = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RefSelect` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        index: O0,
        inputs: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(index.into(), inputs.into(), scope)
    }
    fn build_impl(
        &self,
        index: crate::Output,
        inputs: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("RefSelect", |nd| {
            nd.add_input(index);
            nd.add_input(inputs);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.N {
                nd.set_attr_int("N", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RefSelect' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        index: crate::Output,
        inputs: Vec<crate::Output>,
        scope: &mut crate::Scope,
    ) -> crate::Result<RefSelectInst> {
        let op = scope.new_operation("RefSelect", |builder| {
            builder.add_input(index);
            builder.add_input_list(&inputs);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            builder.set_attr_int("N", inputs.clone().len() as i64)?;
            ::std::result::Result::Ok(())
        })?;
        Ok(RefSelectInst { op })
    }
}
impl RefSelectInst {
    /// Returns the 'output' Output of this 'RefSelect' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'index' Input of this 'RefSelect' operation.
    pub fn index(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns a Vector of inputs for 'inputs' Input of this RefSelect operation.
    pub fn inputs(&self) -> crate::Result<Vec<crate::Input>> {
        let mut Inputs = vec![];
        for i in 1..self.op.get_attr_int("N")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
}
impl From<RefSelectInst> for crate::Operation {
    fn from(inst: RefSelectInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RefSelect::new().build(index, inputs, scope)`.
pub fn ref_select<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    index: O0,
    inputs: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RefSelect::new().build(index, inputs, scope)
}

/// Builder for the `RefSwitch` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RefSwitch {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RefSwitch' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RefSwitchInst {
    /// An instance of a fully built RefSwitch Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RefSwitch {
    /// Creates a new `RefSwitch`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RefSwitch` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        data: O0,
        pred: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(data.into(), pred.into(), scope)
    }
    fn build_impl(
        &self,
        data: crate::Output,
        pred: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("RefSwitch", |nd| {
            nd.add_input(data);
            nd.add_input(pred);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RefSwitch' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        data: crate::Output,
        pred: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<RefSwitchInst> {
        let op = scope.new_operation("RefSwitch", |builder| {
            builder.add_input(data);
            builder.add_input(pred);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RefSwitchInst { op })
    }
}
impl RefSwitchInst {
    /// Returns the 'output_false' Output of this 'RefSwitch' operation.
    pub fn output_false(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'output_true' Output of this 'RefSwitch' operation.
    pub fn output_true(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'data' Input of this 'RefSwitch' operation.
    pub fn data(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'pred' Input of this 'RefSwitch' operation.
    pub fn pred(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<RefSwitchInst> for crate::Operation {
    fn from(inst: RefSwitchInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RefSwitch::new().build(data, pred, scope)`.
pub fn ref_switch<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    data: O0,
    pred: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RefSwitch::new().build(data, pred, scope)
}

/// Builder for the `RegexFullMatch` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RegexFullMatch {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RegexFullMatch' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RegexFullMatchInst {
    /// An instance of a fully built RegexFullMatch Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RegexFullMatch {
    /// Creates a new `RegexFullMatch`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RegexFullMatch` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        pattern: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), pattern.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        pattern: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("RegexFullMatch", |nd| {
            nd.add_input(input);
            nd.add_input(pattern);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RegexFullMatch' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        pattern: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<RegexFullMatchInst> {
        let op = scope.new_operation("RegexFullMatch", |builder| {
            builder.add_input(input);
            builder.add_input(pattern);
            ::std::result::Result::Ok(())
        })?;
        Ok(RegexFullMatchInst { op })
    }
}
impl RegexFullMatchInst {
    /// Returns the 'output' Output of this 'RegexFullMatch' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'RegexFullMatch' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'pattern' Input of this 'RegexFullMatch' operation.
    pub fn pattern(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<RegexFullMatchInst> for crate::Operation {
    fn from(inst: RegexFullMatchInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RegexFullMatch::new().build(input, pattern, scope)`.
pub fn regex_full_match<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    input: O0,
    pattern: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RegexFullMatch::new().build(input, pattern, scope)
}

/// Builder for the `RegexReplace` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RegexReplace {
    replace_global: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RegexReplace' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RegexReplaceInst {
    /// An instance of a fully built RegexReplace Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RegexReplace {
    /// Creates a new `RegexReplace`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `replace_global` attribute.
    pub fn replace_global<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.replace_global = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RegexReplace` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        pattern: O1,
        rewrite: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), pattern.into(), rewrite.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        pattern: crate::Output,
        rewrite: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("RegexReplace", |nd| {
            nd.add_input(input);
            nd.add_input(pattern);
            nd.add_input(rewrite);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.replace_global {
                nd.set_attr_bool("replace_global", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RegexReplace' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        pattern: crate::Output,
        rewrite: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<RegexReplaceInst> {
        let op = scope.new_operation("RegexReplace", |builder| {
            builder.add_input(input);
            builder.add_input(pattern);
            builder.add_input(rewrite);
            if let ::std::option::Option::Some(value) = &self.replace_global {
                builder.set_attr_bool("replace_global", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RegexReplaceInst { op })
    }
}
impl RegexReplaceInst {
    /// Returns the 'output' Output of this 'RegexReplace' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'RegexReplace' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'pattern' Input of this 'RegexReplace' operation.
    pub fn pattern(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'rewrite' Input of this 'RegexReplace' operation.
    pub fn rewrite(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<RegexReplaceInst> for crate::Operation {
    fn from(inst: RegexReplaceInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RegexReplace::new().build(input, pattern, rewrite, scope)`.
pub fn regex_replace<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    input: O0,
    pattern: O1,
    rewrite: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RegexReplace::new().build(input, pattern, rewrite, scope)
}

/// Builder for the `RegisterDataset` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RegisterDataset {
    external_state_policy: ::std::option::Option<i64>,
    element_spec: ::std::option::Option<::std::string::String>,
    metadata: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RegisterDataset' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RegisterDatasetInst {
    /// An instance of a fully built RegisterDataset Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RegisterDataset {
    /// Creates a new `RegisterDataset`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `external_state_policy` attribute.
    pub fn external_state_policy<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.external_state_policy = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `element_spec` attribute.
    pub fn element_spec<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.element_spec = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `metadata` attribute.
    pub fn metadata<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.metadata = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RegisterDataset` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        dataset: O0,
        address: O1,
        protocol: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(dataset.into(), address.into(), protocol.into(), scope)
    }
    fn build_impl(
        &self,
        dataset: crate::Output,
        address: crate::Output,
        protocol: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("RegisterDataset", |nd| {
            nd.add_input(dataset);
            nd.add_input(address);
            nd.add_input(protocol);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.external_state_policy {
                nd.set_attr_int("external_state_policy", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.element_spec {
                nd.set_attr_string("element_spec", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.metadata {
                nd.set_attr_string("metadata", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RegisterDataset' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        dataset: crate::Output,
        address: crate::Output,
        protocol: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<RegisterDatasetInst> {
        let op = scope.new_operation("RegisterDataset", |builder| {
            builder.add_input(dataset);
            builder.add_input(address);
            builder.add_input(protocol);
            if let ::std::option::Option::Some(value) = &self.external_state_policy {
                builder.set_attr_int("external_state_policy", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.element_spec {
                builder.set_attr_string("element_spec", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.metadata {
                builder.set_attr_string("metadata", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RegisterDatasetInst { op })
    }
}
impl RegisterDatasetInst {
    /// Returns the 'dataset_id' Output of this 'RegisterDataset' operation.
    pub fn dataset_id(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'dataset' Input of this 'RegisterDataset' operation.
    pub fn dataset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'address' Input of this 'RegisterDataset' operation.
    pub fn address(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'protocol' Input of this 'RegisterDataset' operation.
    pub fn protocol(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<RegisterDatasetInst> for crate::Operation {
    fn from(inst: RegisterDatasetInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RegisterDataset::new().build(dataset, address, protocol, scope)`.
pub fn register_dataset<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    dataset: O0,
    address: O1,
    protocol: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RegisterDataset::new().build(dataset, address, protocol, scope)
}

/// Builder for the `RegisterDatasetV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RegisterDatasetV2 {
    external_state_policy: ::std::option::Option<i64>,
    element_spec: ::std::option::Option<::std::string::String>,
    requested_dataset_id: ::std::option::Option<::std::string::String>,
    metadata: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RegisterDatasetV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RegisterDatasetV2Inst {
    /// An instance of a fully built RegisterDatasetV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RegisterDatasetV2 {
    /// Creates a new `RegisterDatasetV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `external_state_policy` attribute.
    pub fn external_state_policy<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.external_state_policy = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `element_spec` attribute.
    pub fn element_spec<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.element_spec = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `requested_dataset_id` attribute.
    pub fn requested_dataset_id<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.requested_dataset_id = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `metadata` attribute.
    pub fn metadata<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.metadata = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RegisterDatasetV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        dataset: O0,
        address: O1,
        protocol: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(dataset.into(), address.into(), protocol.into(), scope)
    }
    fn build_impl(
        &self,
        dataset: crate::Output,
        address: crate::Output,
        protocol: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("RegisterDatasetV2", |nd| {
            nd.add_input(dataset);
            nd.add_input(address);
            nd.add_input(protocol);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.external_state_policy {
                nd.set_attr_int("external_state_policy", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.element_spec {
                nd.set_attr_string("element_spec", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.requested_dataset_id {
                nd.set_attr_string("requested_dataset_id", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.metadata {
                nd.set_attr_string("metadata", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RegisterDatasetV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        dataset: crate::Output,
        address: crate::Output,
        protocol: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<RegisterDatasetV2Inst> {
        let op = scope.new_operation("RegisterDatasetV2", |builder| {
            builder.add_input(dataset);
            builder.add_input(address);
            builder.add_input(protocol);
            if let ::std::option::Option::Some(value) = &self.external_state_policy {
                builder.set_attr_int("external_state_policy", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.element_spec {
                builder.set_attr_string("element_spec", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.requested_dataset_id {
                builder.set_attr_string("requested_dataset_id", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.metadata {
                builder.set_attr_string("metadata", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RegisterDatasetV2Inst { op })
    }
}
impl RegisterDatasetV2Inst {
    /// Returns the 'dataset_id' Output of this 'RegisterDatasetV2' operation.
    pub fn dataset_id(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'dataset' Input of this 'RegisterDatasetV2' operation.
    pub fn dataset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'address' Input of this 'RegisterDatasetV2' operation.
    pub fn address(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'protocol' Input of this 'RegisterDatasetV2' operation.
    pub fn protocol(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<RegisterDatasetV2Inst> for crate::Operation {
    fn from(inst: RegisterDatasetV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RegisterDatasetV2::new().build(dataset, address, protocol, scope)`.
pub fn register_dataset_v2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    dataset: O0,
    address: O1,
    protocol: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RegisterDatasetV2::new().build(dataset, address, protocol, scope)
}

/// Builder for the `Relayout` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Relayout {
    layout: ::std::option::Option<::std::string::String>,
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Relayout' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RelayoutInst {
    /// An instance of a fully built Relayout Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Relayout {
    /// Creates a new `Relayout`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `layout` attribute.
    pub fn layout<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.layout = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Relayout` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Relayout", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.layout {
                nd.set_attr_string("layout", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Relayout' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<RelayoutInst> {
        let op = scope.new_operation("Relayout", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.layout {
                builder.set_attr_string("layout", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RelayoutInst { op })
    }
}
impl RelayoutInst {
    /// Returns the 'output' Output of this 'Relayout' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'Relayout' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<RelayoutInst> for crate::Operation {
    fn from(inst: RelayoutInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Relayout::new().build(input, scope)`.
pub fn relayout<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Relayout::new().build(input, scope)
}

/// Builder for the `RelayoutGrad` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RelayoutGrad {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RelayoutGrad' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RelayoutGradInst {
    /// An instance of a fully built RelayoutGrad Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RelayoutGrad {
    /// Creates a new `RelayoutGrad`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RelayoutGrad` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        forward_input: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), forward_input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        forward_input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("RelayoutGrad", |nd| {
            nd.add_input(input);
            nd.add_input(forward_input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RelayoutGrad' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        forward_input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<RelayoutGradInst> {
        let op = scope.new_operation("RelayoutGrad", |builder| {
            builder.add_input(input);
            builder.add_input(forward_input);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RelayoutGradInst { op })
    }
}
impl RelayoutGradInst {
    /// Returns the 'output' Output of this 'RelayoutGrad' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'RelayoutGrad' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'forward_input' Input of this 'RelayoutGrad' operation.
    pub fn forward_input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<RelayoutGradInst> for crate::Operation {
    fn from(inst: RelayoutGradInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RelayoutGrad::new().build(input, forward_input, scope)`.
pub fn relayout_grad<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    input: O0,
    forward_input: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RelayoutGrad::new().build(input, forward_input, scope)
}

/// Builder for the `Relu` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Relu {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Relu' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ReluInst {
    /// An instance of a fully built Relu Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Relu {
    /// Creates a new `Relu`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Relu` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        features: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(features.into(), scope)
    }
    fn build_impl(
        &self,
        features: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Relu", |nd| {
            nd.add_input(features);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Relu' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        features: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ReluInst> {
        let op = scope.new_operation("Relu", |builder| {
            builder.add_input(features);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ReluInst { op })
    }
}
impl ReluInst {
    /// Returns the 'activations' Output of this 'Relu' operation.
    pub fn activations(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'features' Input of this 'Relu' operation.
    pub fn features(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<ReluInst> for crate::Operation {
    fn from(inst: ReluInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Relu::new().build(features, scope)`.
pub fn relu<O0: ::std::convert::Into<crate::Output>>(
    features: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Relu::new().build(features, scope)
}

/// Builder for the `Relu6` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Relu6 {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Relu6' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct Relu6Inst {
    /// An instance of a fully built Relu6 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Relu6 {
    /// Creates a new `Relu6`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Relu6` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        features: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(features.into(), scope)
    }
    fn build_impl(
        &self,
        features: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Relu6", |nd| {
            nd.add_input(features);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Relu6' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        features: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<Relu6Inst> {
        let op = scope.new_operation("Relu6", |builder| {
            builder.add_input(features);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(Relu6Inst { op })
    }
}
impl Relu6Inst {
    /// Returns the 'activations' Output of this 'Relu6' operation.
    pub fn activations(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'features' Input of this 'Relu6' operation.
    pub fn features(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<Relu6Inst> for crate::Operation {
    fn from(inst: Relu6Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Relu6::new().build(features, scope)`.
pub fn relu6<O0: ::std::convert::Into<crate::Output>>(
    features: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Relu6::new().build(features, scope)
}

/// Builder for the `Relu6Grad` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Relu6Grad {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Relu6Grad' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct Relu6GradInst {
    /// An instance of a fully built Relu6Grad Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Relu6Grad {
    /// Creates a new `Relu6Grad`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Relu6Grad` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        gradients: O0,
        features: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(gradients.into(), features.into(), scope)
    }
    fn build_impl(
        &self,
        gradients: crate::Output,
        features: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Relu6Grad", |nd| {
            nd.add_input(gradients);
            nd.add_input(features);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Relu6Grad' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        gradients: crate::Output,
        features: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<Relu6GradInst> {
        let op = scope.new_operation("Relu6Grad", |builder| {
            builder.add_input(gradients);
            builder.add_input(features);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(Relu6GradInst { op })
    }
}
impl Relu6GradInst {
    /// Returns the 'backprops' Output of this 'Relu6Grad' operation.
    pub fn backprops(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'gradients' Input of this 'Relu6Grad' operation.
    pub fn gradients(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'features' Input of this 'Relu6Grad' operation.
    pub fn features(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<Relu6GradInst> for crate::Operation {
    fn from(inst: Relu6GradInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Relu6Grad::new().build(gradients, features, scope)`.
pub fn relu6_grad<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    gradients: O0,
    features: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Relu6Grad::new().build(gradients, features, scope)
}

/// Builder for the `ReluGrad` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ReluGrad {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ReluGrad' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ReluGradInst {
    /// An instance of a fully built ReluGrad Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ReluGrad {
    /// Creates a new `ReluGrad`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ReluGrad` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        gradients: O0,
        features: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(gradients.into(), features.into(), scope)
    }
    fn build_impl(
        &self,
        gradients: crate::Output,
        features: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ReluGrad", |nd| {
            nd.add_input(gradients);
            nd.add_input(features);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ReluGrad' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        gradients: crate::Output,
        features: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ReluGradInst> {
        let op = scope.new_operation("ReluGrad", |builder| {
            builder.add_input(gradients);
            builder.add_input(features);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ReluGradInst { op })
    }
}
impl ReluGradInst {
    /// Returns the 'backprops' Output of this 'ReluGrad' operation.
    pub fn backprops(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'gradients' Input of this 'ReluGrad' operation.
    pub fn gradients(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'features' Input of this 'ReluGrad' operation.
    pub fn features(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<ReluGradInst> for crate::Operation {
    fn from(inst: ReluGradInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ReluGrad::new().build(gradients, features, scope)`.
pub fn relu_grad<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    gradients: O0,
    features: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ReluGrad::new().build(gradients, features, scope)
}

/// Builder for the `RemoteCall` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RemoteCall {
    Tin: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    Tout: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    f: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RemoteCall' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RemoteCallInst {
    /// An instance of a fully built RemoteCall Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RemoteCall {
    /// Creates a new `RemoteCall`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `Tin` attribute.
    pub fn Tin<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tin = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tout` attribute.
    pub fn Tout<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tout = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `f` attribute.
    pub fn f<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.f = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RemoteCall` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        target: O0,
        args: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(target.into(), args.into(), scope)
    }
    fn build_impl(
        &self,
        target: crate::Output,
        args: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("RemoteCall", |nd| {
            nd.add_input(target);
            nd.add_input(args);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.Tin {
                nd.set_attr_type_list("Tin", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tout {
                nd.set_attr_type_list("Tout", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.f {
                nd.set_attr_string("f", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RemoteCall' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        target: crate::Output,
        args: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<RemoteCallInst> {
        let op = scope.new_operation("RemoteCall", |builder| {
            builder.add_input(target);
            builder.add_input(args);
            if let ::std::option::Option::Some(value) = &self.Tin {
                builder.set_attr_type_list("Tin", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tout {
                builder.set_attr_type_list("Tout", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.f {
                builder.set_attr_string("f", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RemoteCallInst { op })
    }
}
impl RemoteCallInst {
    /// Returns the 'output' Output of this 'RemoteCall' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'target' Input of this 'RemoteCall' operation.
    pub fn target(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'args' Input of this 'RemoteCall' operation.
    pub fn args(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<RemoteCallInst> for crate::Operation {
    fn from(inst: RemoteCallInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RemoteCall::new().build(target, args, scope)`.
pub fn remote_call<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    target: O0,
    args: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RemoteCall::new().build(target, args, scope)
}

/// Builder for the `RepeatDataset` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RepeatDataset {
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    metadata: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RepeatDataset' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RepeatDatasetInst {
    /// An instance of a fully built RepeatDataset Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RepeatDataset {
    /// Creates a new `RepeatDataset`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `metadata` attribute.
    pub fn metadata<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.metadata = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RepeatDataset` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input_dataset: O0,
        count: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input_dataset.into(), count.into(), scope)
    }
    fn build_impl(
        &self,
        input_dataset: crate::Output,
        count: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("RepeatDataset", |nd| {
            nd.add_input(input_dataset);
            nd.add_input(count);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.metadata {
                nd.set_attr_string("metadata", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RepeatDataset' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_dataset: crate::Output,
        count: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<RepeatDatasetInst> {
        let op = scope.new_operation("RepeatDataset", |builder| {
            builder.add_input(input_dataset);
            builder.add_input(count);
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.metadata {
                builder.set_attr_string("metadata", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RepeatDatasetInst { op })
    }
}
impl RepeatDatasetInst {
    /// Returns the 'handle' Output of this 'RepeatDataset' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_dataset' Input of this 'RepeatDataset' operation.
    pub fn input_dataset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'count' Input of this 'RepeatDataset' operation.
    pub fn count(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<RepeatDatasetInst> for crate::Operation {
    fn from(inst: RepeatDatasetInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RepeatDataset::new().build(input_dataset, count, scope)`.
pub fn repeat_dataset<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    input_dataset: O0,
    count: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RepeatDataset::new().build(input_dataset, count, scope)
}

/// Builder for the `RequantizationRange` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RequantizationRange {
    Tinput: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RequantizationRange' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RequantizationRangeInst {
    /// An instance of a fully built RequantizationRange Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RequantizationRange {
    /// Creates a new `RequantizationRange`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `Tinput` attribute.
    pub fn Tinput<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tinput = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RequantizationRange` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        input_min: O1,
        input_max: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), input_min.into(), input_max.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        input_min: crate::Output,
        input_max: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("RequantizationRange", |nd| {
            nd.add_input(input);
            nd.add_input(input_min);
            nd.add_input(input_max);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.Tinput {
                nd.set_attr_type("Tinput", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RequantizationRange' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        input_min: crate::Output,
        input_max: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<RequantizationRangeInst> {
        let op = scope.new_operation("RequantizationRange", |builder| {
            builder.add_input(input);
            builder.add_input(input_min);
            builder.add_input(input_max);
            if let ::std::option::Option::Some(value) = &self.Tinput {
                builder.set_attr_type("Tinput", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RequantizationRangeInst { op })
    }
}
impl RequantizationRangeInst {
    /// Returns the 'output_min' Output of this 'RequantizationRange' operation.
    pub fn output_min(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'output_max' Output of this 'RequantizationRange' operation.
    pub fn output_max(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'input' Input of this 'RequantizationRange' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'input_min' Input of this 'RequantizationRange' operation.
    pub fn input_min(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'input_max' Input of this 'RequantizationRange' operation.
    pub fn input_max(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<RequantizationRangeInst> for crate::Operation {
    fn from(inst: RequantizationRangeInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RequantizationRange::new().build(input, input_min, input_max, scope)`.
pub fn requantization_range<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    input: O0,
    input_min: O1,
    input_max: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RequantizationRange::new().build(input, input_min, input_max, scope)
}

/// Builder for the `RequantizationRangePerChannel` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RequantizationRangePerChannel {
    T: ::std::option::Option<crate::DataType>,
    clip_value_max: ::std::option::Option<f32>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RequantizationRangePerChannel' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RequantizationRangePerChannelInst {
    /// An instance of a fully built RequantizationRangePerChannel Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RequantizationRangePerChannel {
    /// Creates a new `RequantizationRangePerChannel`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `clip_value_max` attribute.
    pub fn clip_value_max<ArgType: ::std::convert::Into<f32>>(mut self, value: ArgType) -> Self {
        self.clip_value_max = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RequantizationRangePerChannel` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        input_min: O1,
        input_max: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), input_min.into(), input_max.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        input_min: crate::Output,
        input_max: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("RequantizationRangePerChannel", |nd| {
            nd.add_input(input);
            nd.add_input(input_min);
            nd.add_input(input_max);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.clip_value_max {
                nd.set_attr_float("clip_value_max", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RequantizationRangePerChannel' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        input_min: crate::Output,
        input_max: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<RequantizationRangePerChannelInst> {
        let op = scope.new_operation("RequantizationRangePerChannel", |builder| {
            builder.add_input(input);
            builder.add_input(input_min);
            builder.add_input(input_max);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.clip_value_max {
                builder.set_attr_float("clip_value_max", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RequantizationRangePerChannelInst { op })
    }
}
impl RequantizationRangePerChannelInst {
    /// Returns the 'output_min' Output of this 'RequantizationRangePerChannel' operation.
    pub fn output_min(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'output_max' Output of this 'RequantizationRangePerChannel' operation.
    pub fn output_max(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'input' Input of this 'RequantizationRangePerChannel' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'input_min' Input of this 'RequantizationRangePerChannel' operation.
    pub fn input_min(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'input_max' Input of this 'RequantizationRangePerChannel' operation.
    pub fn input_max(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<RequantizationRangePerChannelInst> for crate::Operation {
    fn from(inst: RequantizationRangePerChannelInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RequantizationRangePerChannel::new().build(input, input_min, input_max, scope)`.
pub fn requantization_range_per_channel<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    input: O0,
    input_min: O1,
    input_max: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RequantizationRangePerChannel::new().build(input, input_min, input_max, scope)
}

/// Builder for the `Requantize` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Requantize {
    Tinput: ::std::option::Option<crate::DataType>,
    out_type: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Requantize' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RequantizeInst {
    /// An instance of a fully built Requantize Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Requantize {
    /// Creates a new `Requantize`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `Tinput` attribute.
    pub fn Tinput<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tinput = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `out_type` attribute.
    pub fn out_type<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.out_type = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Requantize` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        input_min: O1,
        input_max: O2,
        requested_output_min: O3,
        requested_output_max: O4,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            input.into(),
            input_min.into(),
            input_max.into(),
            requested_output_min.into(),
            requested_output_max.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        input: crate::Output,
        input_min: crate::Output,
        input_max: crate::Output,
        requested_output_min: crate::Output,
        requested_output_max: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Requantize", |nd| {
            nd.add_input(input);
            nd.add_input(input_min);
            nd.add_input(input_max);
            nd.add_input(requested_output_min);
            nd.add_input(requested_output_max);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.Tinput {
                nd.set_attr_type("Tinput", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.out_type {
                nd.set_attr_type("out_type", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Requantize' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        input_min: crate::Output,
        input_max: crate::Output,
        requested_output_min: crate::Output,
        requested_output_max: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<RequantizeInst> {
        let op = scope.new_operation("Requantize", |builder| {
            builder.add_input(input);
            builder.add_input(input_min);
            builder.add_input(input_max);
            builder.add_input(requested_output_min);
            builder.add_input(requested_output_max);
            if let ::std::option::Option::Some(value) = &self.Tinput {
                builder.set_attr_type("Tinput", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.out_type {
                builder.set_attr_type("out_type", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RequantizeInst { op })
    }
}
impl RequantizeInst {
    /// Returns the 'output' Output of this 'Requantize' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'output_min' Output of this 'Requantize' operation.
    pub fn output_min(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'output_max' Output of this 'Requantize' operation.
    pub fn output_max(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns the 'input' Input of this 'Requantize' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'input_min' Input of this 'Requantize' operation.
    pub fn input_min(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'input_max' Input of this 'Requantize' operation.
    pub fn input_max(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'requested_output_min' Input of this 'Requantize' operation.
    pub fn requested_output_min(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'requested_output_max' Input of this 'Requantize' operation.
    pub fn requested_output_max(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
}
impl From<RequantizeInst> for crate::Operation {
    fn from(inst: RequantizeInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Requantize::new().build(input, input_min, input_max, requested_output_min, requested_output_max, scope)`.
pub fn requantize<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
>(
    input: O0,
    input_min: O1,
    input_max: O2,
    requested_output_min: O3,
    requested_output_max: O4,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Requantize::new().build(
        input,
        input_min,
        input_max,
        requested_output_min,
        requested_output_max,
        scope,
    )
}

/// Builder for the `RequantizePerChannel` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RequantizePerChannel {
    T: ::std::option::Option<crate::DataType>,
    out_type: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RequantizePerChannel' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RequantizePerChannelInst {
    /// An instance of a fully built RequantizePerChannel Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RequantizePerChannel {
    /// Creates a new `RequantizePerChannel`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `out_type` attribute.
    pub fn out_type<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.out_type = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RequantizePerChannel` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        input_min: O1,
        input_max: O2,
        requested_output_min: O3,
        requested_output_max: O4,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            input.into(),
            input_min.into(),
            input_max.into(),
            requested_output_min.into(),
            requested_output_max.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        input: crate::Output,
        input_min: crate::Output,
        input_max: crate::Output,
        requested_output_min: crate::Output,
        requested_output_max: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("RequantizePerChannel", |nd| {
            nd.add_input(input);
            nd.add_input(input_min);
            nd.add_input(input_max);
            nd.add_input(requested_output_min);
            nd.add_input(requested_output_max);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.out_type {
                nd.set_attr_type("out_type", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RequantizePerChannel' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        input_min: crate::Output,
        input_max: crate::Output,
        requested_output_min: crate::Output,
        requested_output_max: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<RequantizePerChannelInst> {
        let op = scope.new_operation("RequantizePerChannel", |builder| {
            builder.add_input(input);
            builder.add_input(input_min);
            builder.add_input(input_max);
            builder.add_input(requested_output_min);
            builder.add_input(requested_output_max);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.out_type {
                builder.set_attr_type("out_type", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RequantizePerChannelInst { op })
    }
}
impl RequantizePerChannelInst {
    /// Returns the 'output' Output of this 'RequantizePerChannel' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'output_min' Output of this 'RequantizePerChannel' operation.
    pub fn output_min(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'output_max' Output of this 'RequantizePerChannel' operation.
    pub fn output_max(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns the 'input' Input of this 'RequantizePerChannel' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'input_min' Input of this 'RequantizePerChannel' operation.
    pub fn input_min(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'input_max' Input of this 'RequantizePerChannel' operation.
    pub fn input_max(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'requested_output_min' Input of this 'RequantizePerChannel' operation.
    pub fn requested_output_min(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'requested_output_max' Input of this 'RequantizePerChannel' operation.
    pub fn requested_output_max(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
}
impl From<RequantizePerChannelInst> for crate::Operation {
    fn from(inst: RequantizePerChannelInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RequantizePerChannel::new().build(input, input_min, input_max, requested_output_min, requested_output_max, scope)`.
pub fn requantize_per_channel<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
>(
    input: O0,
    input_min: O1,
    input_max: O2,
    requested_output_min: O3,
    requested_output_max: O4,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RequantizePerChannel::new().build(
        input,
        input_min,
        input_max,
        requested_output_min,
        requested_output_max,
        scope,
    )
}

/// Builder for the `Reshape` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Reshape {
    T: ::std::option::Option<crate::DataType>,
    Tshape: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Reshape' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ReshapeInst {
    /// An instance of a fully built Reshape Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Reshape {
    /// Creates a new `Reshape`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tshape` attribute.
    pub fn Tshape<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tshape = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Reshape` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        tensor: O0,
        shape: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(tensor.into(), shape.into(), scope)
    }
    fn build_impl(
        &self,
        tensor: crate::Output,
        shape: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Reshape", |nd| {
            nd.add_input(tensor);
            nd.add_input(shape);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tshape {
                nd.set_attr_type("Tshape", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Reshape' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        tensor: crate::Output,
        shape: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ReshapeInst> {
        let op = scope.new_operation("Reshape", |builder| {
            builder.add_input(tensor);
            builder.add_input(shape);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tshape {
                builder.set_attr_type("Tshape", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ReshapeInst { op })
    }
}
impl ReshapeInst {
    /// Returns the 'output' Output of this 'Reshape' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'tensor' Input of this 'Reshape' operation.
    pub fn tensor(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'shape' Input of this 'Reshape' operation.
    pub fn shape(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<ReshapeInst> for crate::Operation {
    fn from(inst: ReshapeInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Reshape::new().build(tensor, shape, scope)`.
pub fn reshape<O0: ::std::convert::Into<crate::Output>, O1: ::std::convert::Into<crate::Output>>(
    tensor: O0,
    shape: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Reshape::new().build(tensor, shape, scope)
}

/// Builder for the `ResizeArea` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ResizeArea {
    T: ::std::option::Option<crate::DataType>,
    align_corners: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ResizeArea' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ResizeAreaInst {
    /// An instance of a fully built ResizeArea Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ResizeArea {
    /// Creates a new `ResizeArea`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `align_corners` attribute.
    pub fn align_corners<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.align_corners = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ResizeArea` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        images: O0,
        size: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(images.into(), size.into(), scope)
    }
    fn build_impl(
        &self,
        images: crate::Output,
        size: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ResizeArea", |nd| {
            nd.add_input(images);
            nd.add_input(size);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.align_corners {
                nd.set_attr_bool("align_corners", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ResizeArea' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        images: crate::Output,
        size: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ResizeAreaInst> {
        let op = scope.new_operation("ResizeArea", |builder| {
            builder.add_input(images);
            builder.add_input(size);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.align_corners {
                builder.set_attr_bool("align_corners", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ResizeAreaInst { op })
    }
}
impl ResizeAreaInst {
    /// Returns the 'resized_images' Output of this 'ResizeArea' operation.
    pub fn resized_images(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'images' Input of this 'ResizeArea' operation.
    pub fn images(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'size' Input of this 'ResizeArea' operation.
    pub fn size(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<ResizeAreaInst> for crate::Operation {
    fn from(inst: ResizeAreaInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ResizeArea::new().build(images, size, scope)`.
pub fn resize_area<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    images: O0,
    size: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ResizeArea::new().build(images, size, scope)
}

/// Builder for the `ResizeBicubic` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ResizeBicubic {
    T: ::std::option::Option<crate::DataType>,
    align_corners: ::std::option::Option<bool>,
    half_pixel_centers: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ResizeBicubic' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ResizeBicubicInst {
    /// An instance of a fully built ResizeBicubic Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ResizeBicubic {
    /// Creates a new `ResizeBicubic`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `align_corners` attribute.
    pub fn align_corners<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.align_corners = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `half_pixel_centers` attribute.
    pub fn half_pixel_centers<ArgType: ::std::convert::Into<bool>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.half_pixel_centers = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ResizeBicubic` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        images: O0,
        size: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(images.into(), size.into(), scope)
    }
    fn build_impl(
        &self,
        images: crate::Output,
        size: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ResizeBicubic", |nd| {
            nd.add_input(images);
            nd.add_input(size);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.align_corners {
                nd.set_attr_bool("align_corners", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.half_pixel_centers {
                nd.set_attr_bool("half_pixel_centers", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ResizeBicubic' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        images: crate::Output,
        size: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ResizeBicubicInst> {
        let op = scope.new_operation("ResizeBicubic", |builder| {
            builder.add_input(images);
            builder.add_input(size);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.align_corners {
                builder.set_attr_bool("align_corners", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.half_pixel_centers {
                builder.set_attr_bool("half_pixel_centers", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ResizeBicubicInst { op })
    }
}
impl ResizeBicubicInst {
    /// Returns the 'resized_images' Output of this 'ResizeBicubic' operation.
    pub fn resized_images(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'images' Input of this 'ResizeBicubic' operation.
    pub fn images(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'size' Input of this 'ResizeBicubic' operation.
    pub fn size(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<ResizeBicubicInst> for crate::Operation {
    fn from(inst: ResizeBicubicInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ResizeBicubic::new().build(images, size, scope)`.
pub fn resize_bicubic<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    images: O0,
    size: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ResizeBicubic::new().build(images, size, scope)
}

/// Builder for the `ResizeBicubicGrad` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ResizeBicubicGrad {
    T: ::std::option::Option<crate::DataType>,
    align_corners: ::std::option::Option<bool>,
    half_pixel_centers: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ResizeBicubicGrad' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ResizeBicubicGradInst {
    /// An instance of a fully built ResizeBicubicGrad Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ResizeBicubicGrad {
    /// Creates a new `ResizeBicubicGrad`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `align_corners` attribute.
    pub fn align_corners<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.align_corners = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `half_pixel_centers` attribute.
    pub fn half_pixel_centers<ArgType: ::std::convert::Into<bool>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.half_pixel_centers = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ResizeBicubicGrad` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        grads: O0,
        original_image: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(grads.into(), original_image.into(), scope)
    }
    fn build_impl(
        &self,
        grads: crate::Output,
        original_image: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ResizeBicubicGrad", |nd| {
            nd.add_input(grads);
            nd.add_input(original_image);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.align_corners {
                nd.set_attr_bool("align_corners", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.half_pixel_centers {
                nd.set_attr_bool("half_pixel_centers", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ResizeBicubicGrad' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        grads: crate::Output,
        original_image: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ResizeBicubicGradInst> {
        let op = scope.new_operation("ResizeBicubicGrad", |builder| {
            builder.add_input(grads);
            builder.add_input(original_image);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.align_corners {
                builder.set_attr_bool("align_corners", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.half_pixel_centers {
                builder.set_attr_bool("half_pixel_centers", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ResizeBicubicGradInst { op })
    }
}
impl ResizeBicubicGradInst {
    /// Returns the 'output' Output of this 'ResizeBicubicGrad' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'grads' Input of this 'ResizeBicubicGrad' operation.
    pub fn grads(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'original_image' Input of this 'ResizeBicubicGrad' operation.
    pub fn original_image(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<ResizeBicubicGradInst> for crate::Operation {
    fn from(inst: ResizeBicubicGradInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ResizeBicubicGrad::new().build(grads, original_image, scope)`.
pub fn resize_bicubic_grad<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    grads: O0,
    original_image: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ResizeBicubicGrad::new().build(grads, original_image, scope)
}

/// Builder for the `ResizeBilinear` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ResizeBilinear {
    T: ::std::option::Option<crate::DataType>,
    align_corners: ::std::option::Option<bool>,
    half_pixel_centers: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ResizeBilinear' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ResizeBilinearInst {
    /// An instance of a fully built ResizeBilinear Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ResizeBilinear {
    /// Creates a new `ResizeBilinear`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `align_corners` attribute.
    pub fn align_corners<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.align_corners = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `half_pixel_centers` attribute.
    pub fn half_pixel_centers<ArgType: ::std::convert::Into<bool>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.half_pixel_centers = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ResizeBilinear` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        images: O0,
        size: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(images.into(), size.into(), scope)
    }
    fn build_impl(
        &self,
        images: crate::Output,
        size: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ResizeBilinear", |nd| {
            nd.add_input(images);
            nd.add_input(size);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.align_corners {
                nd.set_attr_bool("align_corners", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.half_pixel_centers {
                nd.set_attr_bool("half_pixel_centers", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ResizeBilinear' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        images: crate::Output,
        size: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ResizeBilinearInst> {
        let op = scope.new_operation("ResizeBilinear", |builder| {
            builder.add_input(images);
            builder.add_input(size);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.align_corners {
                builder.set_attr_bool("align_corners", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.half_pixel_centers {
                builder.set_attr_bool("half_pixel_centers", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ResizeBilinearInst { op })
    }
}
impl ResizeBilinearInst {
    /// Returns the 'resized_images' Output of this 'ResizeBilinear' operation.
    pub fn resized_images(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'images' Input of this 'ResizeBilinear' operation.
    pub fn images(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'size' Input of this 'ResizeBilinear' operation.
    pub fn size(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<ResizeBilinearInst> for crate::Operation {
    fn from(inst: ResizeBilinearInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ResizeBilinear::new().build(images, size, scope)`.
pub fn resize_bilinear<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    images: O0,
    size: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ResizeBilinear::new().build(images, size, scope)
}

/// Builder for the `ResizeBilinearGrad` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ResizeBilinearGrad {
    T: ::std::option::Option<crate::DataType>,
    align_corners: ::std::option::Option<bool>,
    half_pixel_centers: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ResizeBilinearGrad' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ResizeBilinearGradInst {
    /// An instance of a fully built ResizeBilinearGrad Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ResizeBilinearGrad {
    /// Creates a new `ResizeBilinearGrad`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `align_corners` attribute.
    pub fn align_corners<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.align_corners = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `half_pixel_centers` attribute.
    pub fn half_pixel_centers<ArgType: ::std::convert::Into<bool>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.half_pixel_centers = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ResizeBilinearGrad` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        grads: O0,
        original_image: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(grads.into(), original_image.into(), scope)
    }
    fn build_impl(
        &self,
        grads: crate::Output,
        original_image: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ResizeBilinearGrad", |nd| {
            nd.add_input(grads);
            nd.add_input(original_image);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.align_corners {
                nd.set_attr_bool("align_corners", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.half_pixel_centers {
                nd.set_attr_bool("half_pixel_centers", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ResizeBilinearGrad' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        grads: crate::Output,
        original_image: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ResizeBilinearGradInst> {
        let op = scope.new_operation("ResizeBilinearGrad", |builder| {
            builder.add_input(grads);
            builder.add_input(original_image);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.align_corners {
                builder.set_attr_bool("align_corners", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.half_pixel_centers {
                builder.set_attr_bool("half_pixel_centers", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ResizeBilinearGradInst { op })
    }
}
impl ResizeBilinearGradInst {
    /// Returns the 'output' Output of this 'ResizeBilinearGrad' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'grads' Input of this 'ResizeBilinearGrad' operation.
    pub fn grads(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'original_image' Input of this 'ResizeBilinearGrad' operation.
    pub fn original_image(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<ResizeBilinearGradInst> for crate::Operation {
    fn from(inst: ResizeBilinearGradInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ResizeBilinearGrad::new().build(grads, original_image, scope)`.
pub fn resize_bilinear_grad<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    grads: O0,
    original_image: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ResizeBilinearGrad::new().build(grads, original_image, scope)
}

/// Builder for the `ResizeNearestNeighbor` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ResizeNearestNeighbor {
    T: ::std::option::Option<crate::DataType>,
    align_corners: ::std::option::Option<bool>,
    half_pixel_centers: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ResizeNearestNeighbor' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ResizeNearestNeighborInst {
    /// An instance of a fully built ResizeNearestNeighbor Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ResizeNearestNeighbor {
    /// Creates a new `ResizeNearestNeighbor`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `align_corners` attribute.
    pub fn align_corners<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.align_corners = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `half_pixel_centers` attribute.
    pub fn half_pixel_centers<ArgType: ::std::convert::Into<bool>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.half_pixel_centers = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ResizeNearestNeighbor` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        images: O0,
        size: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(images.into(), size.into(), scope)
    }
    fn build_impl(
        &self,
        images: crate::Output,
        size: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ResizeNearestNeighbor", |nd| {
            nd.add_input(images);
            nd.add_input(size);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.align_corners {
                nd.set_attr_bool("align_corners", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.half_pixel_centers {
                nd.set_attr_bool("half_pixel_centers", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ResizeNearestNeighbor' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        images: crate::Output,
        size: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ResizeNearestNeighborInst> {
        let op = scope.new_operation("ResizeNearestNeighbor", |builder| {
            builder.add_input(images);
            builder.add_input(size);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.align_corners {
                builder.set_attr_bool("align_corners", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.half_pixel_centers {
                builder.set_attr_bool("half_pixel_centers", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ResizeNearestNeighborInst { op })
    }
}
impl ResizeNearestNeighborInst {
    /// Returns the 'resized_images' Output of this 'ResizeNearestNeighbor' operation.
    pub fn resized_images(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'images' Input of this 'ResizeNearestNeighbor' operation.
    pub fn images(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'size' Input of this 'ResizeNearestNeighbor' operation.
    pub fn size(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<ResizeNearestNeighborInst> for crate::Operation {
    fn from(inst: ResizeNearestNeighborInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ResizeNearestNeighbor::new().build(images, size, scope)`.
pub fn resize_nearest_neighbor<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    images: O0,
    size: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ResizeNearestNeighbor::new().build(images, size, scope)
}

/// Builder for the `ResizeNearestNeighborGrad` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ResizeNearestNeighborGrad {
    T: ::std::option::Option<crate::DataType>,
    align_corners: ::std::option::Option<bool>,
    half_pixel_centers: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ResizeNearestNeighborGrad' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ResizeNearestNeighborGradInst {
    /// An instance of a fully built ResizeNearestNeighborGrad Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ResizeNearestNeighborGrad {
    /// Creates a new `ResizeNearestNeighborGrad`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `align_corners` attribute.
    pub fn align_corners<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.align_corners = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `half_pixel_centers` attribute.
    pub fn half_pixel_centers<ArgType: ::std::convert::Into<bool>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.half_pixel_centers = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ResizeNearestNeighborGrad` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        grads: O0,
        size: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(grads.into(), size.into(), scope)
    }
    fn build_impl(
        &self,
        grads: crate::Output,
        size: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ResizeNearestNeighborGrad", |nd| {
            nd.add_input(grads);
            nd.add_input(size);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.align_corners {
                nd.set_attr_bool("align_corners", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.half_pixel_centers {
                nd.set_attr_bool("half_pixel_centers", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ResizeNearestNeighborGrad' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        grads: crate::Output,
        size: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ResizeNearestNeighborGradInst> {
        let op = scope.new_operation("ResizeNearestNeighborGrad", |builder| {
            builder.add_input(grads);
            builder.add_input(size);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.align_corners {
                builder.set_attr_bool("align_corners", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.half_pixel_centers {
                builder.set_attr_bool("half_pixel_centers", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ResizeNearestNeighborGradInst { op })
    }
}
impl ResizeNearestNeighborGradInst {
    /// Returns the 'output' Output of this 'ResizeNearestNeighborGrad' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'grads' Input of this 'ResizeNearestNeighborGrad' operation.
    pub fn grads(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'size' Input of this 'ResizeNearestNeighborGrad' operation.
    pub fn size(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<ResizeNearestNeighborGradInst> for crate::Operation {
    fn from(inst: ResizeNearestNeighborGradInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ResizeNearestNeighborGrad::new().build(grads, size, scope)`.
pub fn resize_nearest_neighbor_grad<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    grads: O0,
    size: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ResizeNearestNeighborGrad::new().build(grads, size, scope)
}

/// Builder for the `ResourceAccumulatorApplyGradient` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ResourceAccumulatorApplyGradient {
    dtype: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ResourceAccumulatorApplyGradient' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ResourceAccumulatorApplyGradientInst {
    /// An instance of a fully built ResourceAccumulatorApplyGradient Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ResourceAccumulatorApplyGradient {
    /// Creates a new `ResourceAccumulatorApplyGradient`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `dtype` attribute.
    pub fn dtype<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ResourceAccumulatorApplyGradient` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        handle: O0,
        local_step: O1,
        gradient: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(handle.into(), local_step.into(), gradient.into(), scope)
    }
    fn build_impl(
        &self,
        handle: crate::Output,
        local_step: crate::Output,
        gradient: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ResourceAccumulatorApplyGradient", |nd| {
            nd.add_input(handle);
            nd.add_input(local_step);
            nd.add_input(gradient);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                nd.set_attr_type("dtype", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ResourceAccumulatorApplyGradient' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        handle: crate::Output,
        local_step: crate::Output,
        gradient: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ResourceAccumulatorApplyGradientInst> {
        let op = scope.new_operation("ResourceAccumulatorApplyGradient", |builder| {
            builder.add_input(handle);
            builder.add_input(local_step);
            builder.add_input(gradient);
            if let ::std::option::Option::Some(value) = &self.dtype {
                builder.set_attr_type("dtype", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ResourceAccumulatorApplyGradientInst { op })
    }
}
impl ResourceAccumulatorApplyGradientInst {
    /// Returns the 'handle' Input of this 'ResourceAccumulatorApplyGradient' operation.
    pub fn handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'local_step' Input of this 'ResourceAccumulatorApplyGradient' operation.
    pub fn local_step(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'gradient' Input of this 'ResourceAccumulatorApplyGradient' operation.
    pub fn gradient(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<ResourceAccumulatorApplyGradientInst> for crate::Operation {
    fn from(inst: ResourceAccumulatorApplyGradientInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ResourceAccumulatorApplyGradient::new().build(handle, local_step, gradient, scope)`.
pub fn resource_accumulator_apply_gradient<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    handle: O0,
    local_step: O1,
    gradient: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ResourceAccumulatorApplyGradient::new().build(handle, local_step, gradient, scope)
}

/// Builder for the `ResourceAccumulatorNumAccumulated` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ResourceAccumulatorNumAccumulated {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ResourceAccumulatorNumAccumulated' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ResourceAccumulatorNumAccumulatedInst {
    /// An instance of a fully built ResourceAccumulatorNumAccumulated Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ResourceAccumulatorNumAccumulated {
    /// Creates a new `ResourceAccumulatorNumAccumulated`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ResourceAccumulatorNumAccumulated` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        handle: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(handle.into(), scope)
    }
    fn build_impl(
        &self,
        handle: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ResourceAccumulatorNumAccumulated", |nd| {
            nd.add_input(handle);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ResourceAccumulatorNumAccumulated' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        handle: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ResourceAccumulatorNumAccumulatedInst> {
        let op = scope.new_operation("ResourceAccumulatorNumAccumulated", |builder| {
            builder.add_input(handle);
            ::std::result::Result::Ok(())
        })?;
        Ok(ResourceAccumulatorNumAccumulatedInst { op })
    }
}
impl ResourceAccumulatorNumAccumulatedInst {
    /// Returns the 'num_accumulated' Output of this 'ResourceAccumulatorNumAccumulated' operation.
    pub fn num_accumulated(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'handle' Input of this 'ResourceAccumulatorNumAccumulated' operation.
    pub fn handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<ResourceAccumulatorNumAccumulatedInst> for crate::Operation {
    fn from(inst: ResourceAccumulatorNumAccumulatedInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ResourceAccumulatorNumAccumulated::new().build(handle, scope)`.
pub fn resource_accumulator_num_accumulated<O0: ::std::convert::Into<crate::Output>>(
    handle: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ResourceAccumulatorNumAccumulated::new().build(handle, scope)
}

/// Builder for the `ResourceAccumulatorSetGlobalStep` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ResourceAccumulatorSetGlobalStep {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ResourceAccumulatorSetGlobalStep' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ResourceAccumulatorSetGlobalStepInst {
    /// An instance of a fully built ResourceAccumulatorSetGlobalStep Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ResourceAccumulatorSetGlobalStep {
    /// Creates a new `ResourceAccumulatorSetGlobalStep`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ResourceAccumulatorSetGlobalStep` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        handle: O0,
        new_global_step: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(handle.into(), new_global_step.into(), scope)
    }
    fn build_impl(
        &self,
        handle: crate::Output,
        new_global_step: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ResourceAccumulatorSetGlobalStep", |nd| {
            nd.add_input(handle);
            nd.add_input(new_global_step);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ResourceAccumulatorSetGlobalStep' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        handle: crate::Output,
        new_global_step: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ResourceAccumulatorSetGlobalStepInst> {
        let op = scope.new_operation("ResourceAccumulatorSetGlobalStep", |builder| {
            builder.add_input(handle);
            builder.add_input(new_global_step);
            ::std::result::Result::Ok(())
        })?;
        Ok(ResourceAccumulatorSetGlobalStepInst { op })
    }
}
impl ResourceAccumulatorSetGlobalStepInst {
    /// Returns the 'handle' Input of this 'ResourceAccumulatorSetGlobalStep' operation.
    pub fn handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'new_global_step' Input of this 'ResourceAccumulatorSetGlobalStep' operation.
    pub fn new_global_step(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<ResourceAccumulatorSetGlobalStepInst> for crate::Operation {
    fn from(inst: ResourceAccumulatorSetGlobalStepInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ResourceAccumulatorSetGlobalStep::new().build(handle, new_global_step, scope)`.
pub fn resource_accumulator_set_global_step<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    handle: O0,
    new_global_step: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ResourceAccumulatorSetGlobalStep::new().build(handle, new_global_step, scope)
}

/// Builder for the `ResourceAccumulatorTakeGradient` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ResourceAccumulatorTakeGradient {
    dtype: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ResourceAccumulatorTakeGradient' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ResourceAccumulatorTakeGradientInst {
    /// An instance of a fully built ResourceAccumulatorTakeGradient Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ResourceAccumulatorTakeGradient {
    /// Creates a new `ResourceAccumulatorTakeGradient`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `dtype` attribute.
    pub fn dtype<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ResourceAccumulatorTakeGradient` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        handle: O0,
        num_required: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(handle.into(), num_required.into(), scope)
    }
    fn build_impl(
        &self,
        handle: crate::Output,
        num_required: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ResourceAccumulatorTakeGradient", |nd| {
            nd.add_input(handle);
            nd.add_input(num_required);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                nd.set_attr_type("dtype", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ResourceAccumulatorTakeGradient' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        handle: crate::Output,
        num_required: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ResourceAccumulatorTakeGradientInst> {
        let op = scope.new_operation("ResourceAccumulatorTakeGradient", |builder| {
            builder.add_input(handle);
            builder.add_input(num_required);
            if let ::std::option::Option::Some(value) = &self.dtype {
                builder.set_attr_type("dtype", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ResourceAccumulatorTakeGradientInst { op })
    }
}
impl ResourceAccumulatorTakeGradientInst {
    /// Returns the 'average' Output of this 'ResourceAccumulatorTakeGradient' operation.
    pub fn average(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'handle' Input of this 'ResourceAccumulatorTakeGradient' operation.
    pub fn handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'num_required' Input of this 'ResourceAccumulatorTakeGradient' operation.
    pub fn num_required(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<ResourceAccumulatorTakeGradientInst> for crate::Operation {
    fn from(inst: ResourceAccumulatorTakeGradientInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ResourceAccumulatorTakeGradient::new().build(handle, num_required, scope)`.
pub fn resource_accumulator_take_gradient<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    handle: O0,
    num_required: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ResourceAccumulatorTakeGradient::new().build(handle, num_required, scope)
}

/// Builder for the `ResourceApplyAdaMax` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ResourceApplyAdaMax {
    T: ::std::option::Option<crate::DataType>,
    use_locking: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ResourceApplyAdaMax' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ResourceApplyAdaMaxInst {
    /// An instance of a fully built ResourceApplyAdaMax Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ResourceApplyAdaMax {
    /// Creates a new `ResourceApplyAdaMax`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_locking` attribute.
    pub fn use_locking<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.use_locking = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ResourceApplyAdaMax` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
        O6: ::std::convert::Into<crate::Output>,
        O7: ::std::convert::Into<crate::Output>,
        O8: ::std::convert::Into<crate::Output>,
    >(
        &self,
        var: O0,
        m: O1,
        v: O2,
        beta1_power: O3,
        lr: O4,
        beta1: O5,
        beta2: O6,
        epsilon: O7,
        grad: O8,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            var.into(),
            m.into(),
            v.into(),
            beta1_power.into(),
            lr.into(),
            beta1.into(),
            beta2.into(),
            epsilon.into(),
            grad.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        var: crate::Output,
        m: crate::Output,
        v: crate::Output,
        beta1_power: crate::Output,
        lr: crate::Output,
        beta1: crate::Output,
        beta2: crate::Output,
        epsilon: crate::Output,
        grad: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ResourceApplyAdaMax", |nd| {
            nd.add_input(var);
            nd.add_input(m);
            nd.add_input(v);
            nd.add_input(beta1_power);
            nd.add_input(lr);
            nd.add_input(beta1);
            nd.add_input(beta2);
            nd.add_input(epsilon);
            nd.add_input(grad);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                nd.set_attr_bool("use_locking", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ResourceApplyAdaMax' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        var: crate::Output,
        m: crate::Output,
        v: crate::Output,
        beta1_power: crate::Output,
        lr: crate::Output,
        beta1: crate::Output,
        beta2: crate::Output,
        epsilon: crate::Output,
        grad: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ResourceApplyAdaMaxInst> {
        let op = scope.new_operation("ResourceApplyAdaMax", |builder| {
            builder.add_input(var);
            builder.add_input(m);
            builder.add_input(v);
            builder.add_input(beta1_power);
            builder.add_input(lr);
            builder.add_input(beta1);
            builder.add_input(beta2);
            builder.add_input(epsilon);
            builder.add_input(grad);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                builder.set_attr_bool("use_locking", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ResourceApplyAdaMaxInst { op })
    }
}
impl ResourceApplyAdaMaxInst {
    /// Returns the 'var' Input of this 'ResourceApplyAdaMax' operation.
    pub fn var(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'm' Input of this 'ResourceApplyAdaMax' operation.
    pub fn m(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'v' Input of this 'ResourceApplyAdaMax' operation.
    pub fn v(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'beta1_power' Input of this 'ResourceApplyAdaMax' operation.
    pub fn beta1_power(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'lr' Input of this 'ResourceApplyAdaMax' operation.
    pub fn lr(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
    /// Returns the 'beta1' Input of this 'ResourceApplyAdaMax' operation.
    pub fn beta1(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 5,
        }
    }
    /// Returns the 'beta2' Input of this 'ResourceApplyAdaMax' operation.
    pub fn beta2(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 6,
        }
    }
    /// Returns the 'epsilon' Input of this 'ResourceApplyAdaMax' operation.
    pub fn epsilon(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 7,
        }
    }
    /// Returns the 'grad' Input of this 'ResourceApplyAdaMax' operation.
    pub fn grad(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 8,
        }
    }
}
impl From<ResourceApplyAdaMaxInst> for crate::Operation {
    fn from(inst: ResourceApplyAdaMaxInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ResourceApplyAdaMax::new().build(var, m, v, beta1_power, lr, beta1, beta2, epsilon, grad, scope)`.
pub fn resource_apply_ada_max<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
    O6: ::std::convert::Into<crate::Output>,
    O7: ::std::convert::Into<crate::Output>,
    O8: ::std::convert::Into<crate::Output>,
>(
    var: O0,
    m: O1,
    v: O2,
    beta1_power: O3,
    lr: O4,
    beta1: O5,
    beta2: O6,
    epsilon: O7,
    grad: O8,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ResourceApplyAdaMax::new().build(
        var,
        m,
        v,
        beta1_power,
        lr,
        beta1,
        beta2,
        epsilon,
        grad,
        scope,
    )
}

/// Builder for the `ResourceApplyAdadelta` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ResourceApplyAdadelta {
    T: ::std::option::Option<crate::DataType>,
    use_locking: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ResourceApplyAdadelta' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ResourceApplyAdadeltaInst {
    /// An instance of a fully built ResourceApplyAdadelta Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ResourceApplyAdadelta {
    /// Creates a new `ResourceApplyAdadelta`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_locking` attribute.
    pub fn use_locking<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.use_locking = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ResourceApplyAdadelta` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
        O6: ::std::convert::Into<crate::Output>,
    >(
        &self,
        var: O0,
        accum: O1,
        accum_update: O2,
        lr: O3,
        rho: O4,
        epsilon: O5,
        grad: O6,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            var.into(),
            accum.into(),
            accum_update.into(),
            lr.into(),
            rho.into(),
            epsilon.into(),
            grad.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        var: crate::Output,
        accum: crate::Output,
        accum_update: crate::Output,
        lr: crate::Output,
        rho: crate::Output,
        epsilon: crate::Output,
        grad: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ResourceApplyAdadelta", |nd| {
            nd.add_input(var);
            nd.add_input(accum);
            nd.add_input(accum_update);
            nd.add_input(lr);
            nd.add_input(rho);
            nd.add_input(epsilon);
            nd.add_input(grad);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                nd.set_attr_bool("use_locking", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ResourceApplyAdadelta' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        var: crate::Output,
        accum: crate::Output,
        accum_update: crate::Output,
        lr: crate::Output,
        rho: crate::Output,
        epsilon: crate::Output,
        grad: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ResourceApplyAdadeltaInst> {
        let op = scope.new_operation("ResourceApplyAdadelta", |builder| {
            builder.add_input(var);
            builder.add_input(accum);
            builder.add_input(accum_update);
            builder.add_input(lr);
            builder.add_input(rho);
            builder.add_input(epsilon);
            builder.add_input(grad);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                builder.set_attr_bool("use_locking", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ResourceApplyAdadeltaInst { op })
    }
}
impl ResourceApplyAdadeltaInst {
    /// Returns the 'var' Input of this 'ResourceApplyAdadelta' operation.
    pub fn var(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'accum' Input of this 'ResourceApplyAdadelta' operation.
    pub fn accum(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'accum_update' Input of this 'ResourceApplyAdadelta' operation.
    pub fn accum_update(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'lr' Input of this 'ResourceApplyAdadelta' operation.
    pub fn lr(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'rho' Input of this 'ResourceApplyAdadelta' operation.
    pub fn rho(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
    /// Returns the 'epsilon' Input of this 'ResourceApplyAdadelta' operation.
    pub fn epsilon(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 5,
        }
    }
    /// Returns the 'grad' Input of this 'ResourceApplyAdadelta' operation.
    pub fn grad(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 6,
        }
    }
}
impl From<ResourceApplyAdadeltaInst> for crate::Operation {
    fn from(inst: ResourceApplyAdadeltaInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ResourceApplyAdadelta::new().build(var, accum, accum_update, lr, rho, epsilon, grad, scope)`.
pub fn resource_apply_adadelta<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
    O6: ::std::convert::Into<crate::Output>,
>(
    var: O0,
    accum: O1,
    accum_update: O2,
    lr: O3,
    rho: O4,
    epsilon: O5,
    grad: O6,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ResourceApplyAdadelta::new().build(var, accum, accum_update, lr, rho, epsilon, grad, scope)
}

/// Builder for the `ResourceApplyAdagrad` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ResourceApplyAdagrad {
    T: ::std::option::Option<crate::DataType>,
    use_locking: ::std::option::Option<bool>,
    update_slots: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ResourceApplyAdagrad' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ResourceApplyAdagradInst {
    /// An instance of a fully built ResourceApplyAdagrad Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ResourceApplyAdagrad {
    /// Creates a new `ResourceApplyAdagrad`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_locking` attribute.
    pub fn use_locking<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.use_locking = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `update_slots` attribute.
    pub fn update_slots<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.update_slots = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ResourceApplyAdagrad` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
    >(
        &self,
        var: O0,
        accum: O1,
        lr: O2,
        grad: O3,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(var.into(), accum.into(), lr.into(), grad.into(), scope)
    }
    fn build_impl(
        &self,
        var: crate::Output,
        accum: crate::Output,
        lr: crate::Output,
        grad: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ResourceApplyAdagrad", |nd| {
            nd.add_input(var);
            nd.add_input(accum);
            nd.add_input(lr);
            nd.add_input(grad);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                nd.set_attr_bool("use_locking", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.update_slots {
                nd.set_attr_bool("update_slots", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ResourceApplyAdagrad' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        var: crate::Output,
        accum: crate::Output,
        lr: crate::Output,
        grad: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ResourceApplyAdagradInst> {
        let op = scope.new_operation("ResourceApplyAdagrad", |builder| {
            builder.add_input(var);
            builder.add_input(accum);
            builder.add_input(lr);
            builder.add_input(grad);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                builder.set_attr_bool("use_locking", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.update_slots {
                builder.set_attr_bool("update_slots", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ResourceApplyAdagradInst { op })
    }
}
impl ResourceApplyAdagradInst {
    /// Returns the 'var' Input of this 'ResourceApplyAdagrad' operation.
    pub fn var(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'accum' Input of this 'ResourceApplyAdagrad' operation.
    pub fn accum(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'lr' Input of this 'ResourceApplyAdagrad' operation.
    pub fn lr(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'grad' Input of this 'ResourceApplyAdagrad' operation.
    pub fn grad(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
}
impl From<ResourceApplyAdagradInst> for crate::Operation {
    fn from(inst: ResourceApplyAdagradInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ResourceApplyAdagrad::new().build(var, accum, lr, grad, scope)`.
pub fn resource_apply_adagrad<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
>(
    var: O0,
    accum: O1,
    lr: O2,
    grad: O3,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ResourceApplyAdagrad::new().build(var, accum, lr, grad, scope)
}

/// Builder for the `ResourceApplyAdagradDA` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ResourceApplyAdagradDA {
    T: ::std::option::Option<crate::DataType>,
    use_locking: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ResourceApplyAdagradDA' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ResourceApplyAdagradDAInst {
    /// An instance of a fully built ResourceApplyAdagradDA Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ResourceApplyAdagradDA {
    /// Creates a new `ResourceApplyAdagradDA`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_locking` attribute.
    pub fn use_locking<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.use_locking = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ResourceApplyAdagradDA` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
        O6: ::std::convert::Into<crate::Output>,
        O7: ::std::convert::Into<crate::Output>,
    >(
        &self,
        var: O0,
        gradient_accumulator: O1,
        gradient_squared_accumulator: O2,
        grad: O3,
        lr: O4,
        l1: O5,
        l2: O6,
        global_step: O7,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            var.into(),
            gradient_accumulator.into(),
            gradient_squared_accumulator.into(),
            grad.into(),
            lr.into(),
            l1.into(),
            l2.into(),
            global_step.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        var: crate::Output,
        gradient_accumulator: crate::Output,
        gradient_squared_accumulator: crate::Output,
        grad: crate::Output,
        lr: crate::Output,
        l1: crate::Output,
        l2: crate::Output,
        global_step: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ResourceApplyAdagradDA", |nd| {
            nd.add_input(var);
            nd.add_input(gradient_accumulator);
            nd.add_input(gradient_squared_accumulator);
            nd.add_input(grad);
            nd.add_input(lr);
            nd.add_input(l1);
            nd.add_input(l2);
            nd.add_input(global_step);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                nd.set_attr_bool("use_locking", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ResourceApplyAdagradDA' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        var: crate::Output,
        gradient_accumulator: crate::Output,
        gradient_squared_accumulator: crate::Output,
        grad: crate::Output,
        lr: crate::Output,
        l1: crate::Output,
        l2: crate::Output,
        global_step: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ResourceApplyAdagradDAInst> {
        let op = scope.new_operation("ResourceApplyAdagradDA", |builder| {
            builder.add_input(var);
            builder.add_input(gradient_accumulator);
            builder.add_input(gradient_squared_accumulator);
            builder.add_input(grad);
            builder.add_input(lr);
            builder.add_input(l1);
            builder.add_input(l2);
            builder.add_input(global_step);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                builder.set_attr_bool("use_locking", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ResourceApplyAdagradDAInst { op })
    }
}
impl ResourceApplyAdagradDAInst {
    /// Returns the 'var' Input of this 'ResourceApplyAdagradDA' operation.
    pub fn var(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'gradient_accumulator' Input of this 'ResourceApplyAdagradDA' operation.
    pub fn gradient_accumulator(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'gradient_squared_accumulator' Input of this 'ResourceApplyAdagradDA' operation.
    pub fn gradient_squared_accumulator(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'grad' Input of this 'ResourceApplyAdagradDA' operation.
    pub fn grad(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'lr' Input of this 'ResourceApplyAdagradDA' operation.
    pub fn lr(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
    /// Returns the 'l1' Input of this 'ResourceApplyAdagradDA' operation.
    pub fn l1(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 5,
        }
    }
    /// Returns the 'l2' Input of this 'ResourceApplyAdagradDA' operation.
    pub fn l2(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 6,
        }
    }
    /// Returns the 'global_step' Input of this 'ResourceApplyAdagradDA' operation.
    pub fn global_step(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 7,
        }
    }
}
impl From<ResourceApplyAdagradDAInst> for crate::Operation {
    fn from(inst: ResourceApplyAdagradDAInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ResourceApplyAdagradDA::new().build(var, gradient_accumulator, gradient_squared_accumulator, grad, lr, l1, l2, global_step, scope)`.
pub fn resource_apply_adagrad_da<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
    O6: ::std::convert::Into<crate::Output>,
    O7: ::std::convert::Into<crate::Output>,
>(
    var: O0,
    gradient_accumulator: O1,
    gradient_squared_accumulator: O2,
    grad: O3,
    lr: O4,
    l1: O5,
    l2: O6,
    global_step: O7,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ResourceApplyAdagradDA::new().build(
        var,
        gradient_accumulator,
        gradient_squared_accumulator,
        grad,
        lr,
        l1,
        l2,
        global_step,
        scope,
    )
}

/// Builder for the `ResourceApplyAdagradV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ResourceApplyAdagradV2 {
    T: ::std::option::Option<crate::DataType>,
    use_locking: ::std::option::Option<bool>,
    update_slots: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ResourceApplyAdagradV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ResourceApplyAdagradV2Inst {
    /// An instance of a fully built ResourceApplyAdagradV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ResourceApplyAdagradV2 {
    /// Creates a new `ResourceApplyAdagradV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_locking` attribute.
    pub fn use_locking<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.use_locking = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `update_slots` attribute.
    pub fn update_slots<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.update_slots = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ResourceApplyAdagradV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
    >(
        &self,
        var: O0,
        accum: O1,
        lr: O2,
        epsilon: O3,
        grad: O4,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            var.into(),
            accum.into(),
            lr.into(),
            epsilon.into(),
            grad.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        var: crate::Output,
        accum: crate::Output,
        lr: crate::Output,
        epsilon: crate::Output,
        grad: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ResourceApplyAdagradV2", |nd| {
            nd.add_input(var);
            nd.add_input(accum);
            nd.add_input(lr);
            nd.add_input(epsilon);
            nd.add_input(grad);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                nd.set_attr_bool("use_locking", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.update_slots {
                nd.set_attr_bool("update_slots", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ResourceApplyAdagradV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        var: crate::Output,
        accum: crate::Output,
        lr: crate::Output,
        epsilon: crate::Output,
        grad: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ResourceApplyAdagradV2Inst> {
        let op = scope.new_operation("ResourceApplyAdagradV2", |builder| {
            builder.add_input(var);
            builder.add_input(accum);
            builder.add_input(lr);
            builder.add_input(epsilon);
            builder.add_input(grad);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                builder.set_attr_bool("use_locking", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.update_slots {
                builder.set_attr_bool("update_slots", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ResourceApplyAdagradV2Inst { op })
    }
}
impl ResourceApplyAdagradV2Inst {
    /// Returns the 'var' Input of this 'ResourceApplyAdagradV2' operation.
    pub fn var(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'accum' Input of this 'ResourceApplyAdagradV2' operation.
    pub fn accum(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'lr' Input of this 'ResourceApplyAdagradV2' operation.
    pub fn lr(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'epsilon' Input of this 'ResourceApplyAdagradV2' operation.
    pub fn epsilon(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'grad' Input of this 'ResourceApplyAdagradV2' operation.
    pub fn grad(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
}
impl From<ResourceApplyAdagradV2Inst> for crate::Operation {
    fn from(inst: ResourceApplyAdagradV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ResourceApplyAdagradV2::new().build(var, accum, lr, epsilon, grad, scope)`.
pub fn resource_apply_adagrad_v2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
>(
    var: O0,
    accum: O1,
    lr: O2,
    epsilon: O3,
    grad: O4,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ResourceApplyAdagradV2::new().build(var, accum, lr, epsilon, grad, scope)
}

/// Builder for the `ResourceApplyAdam` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ResourceApplyAdam {
    T: ::std::option::Option<crate::DataType>,
    use_locking: ::std::option::Option<bool>,
    use_nesterov: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ResourceApplyAdam' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ResourceApplyAdamInst {
    /// An instance of a fully built ResourceApplyAdam Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ResourceApplyAdam {
    /// Creates a new `ResourceApplyAdam`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_locking` attribute.
    pub fn use_locking<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.use_locking = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_nesterov` attribute.
    pub fn use_nesterov<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.use_nesterov = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ResourceApplyAdam` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
        O6: ::std::convert::Into<crate::Output>,
        O7: ::std::convert::Into<crate::Output>,
        O8: ::std::convert::Into<crate::Output>,
        O9: ::std::convert::Into<crate::Output>,
    >(
        &self,
        var: O0,
        m: O1,
        v: O2,
        beta1_power: O3,
        beta2_power: O4,
        lr: O5,
        beta1: O6,
        beta2: O7,
        epsilon: O8,
        grad: O9,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            var.into(),
            m.into(),
            v.into(),
            beta1_power.into(),
            beta2_power.into(),
            lr.into(),
            beta1.into(),
            beta2.into(),
            epsilon.into(),
            grad.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        var: crate::Output,
        m: crate::Output,
        v: crate::Output,
        beta1_power: crate::Output,
        beta2_power: crate::Output,
        lr: crate::Output,
        beta1: crate::Output,
        beta2: crate::Output,
        epsilon: crate::Output,
        grad: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ResourceApplyAdam", |nd| {
            nd.add_input(var);
            nd.add_input(m);
            nd.add_input(v);
            nd.add_input(beta1_power);
            nd.add_input(beta2_power);
            nd.add_input(lr);
            nd.add_input(beta1);
            nd.add_input(beta2);
            nd.add_input(epsilon);
            nd.add_input(grad);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                nd.set_attr_bool("use_locking", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_nesterov {
                nd.set_attr_bool("use_nesterov", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ResourceApplyAdam' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        var: crate::Output,
        m: crate::Output,
        v: crate::Output,
        beta1_power: crate::Output,
        beta2_power: crate::Output,
        lr: crate::Output,
        beta1: crate::Output,
        beta2: crate::Output,
        epsilon: crate::Output,
        grad: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ResourceApplyAdamInst> {
        let op = scope.new_operation("ResourceApplyAdam", |builder| {
            builder.add_input(var);
            builder.add_input(m);
            builder.add_input(v);
            builder.add_input(beta1_power);
            builder.add_input(beta2_power);
            builder.add_input(lr);
            builder.add_input(beta1);
            builder.add_input(beta2);
            builder.add_input(epsilon);
            builder.add_input(grad);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                builder.set_attr_bool("use_locking", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_nesterov {
                builder.set_attr_bool("use_nesterov", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ResourceApplyAdamInst { op })
    }
}
impl ResourceApplyAdamInst {
    /// Returns the 'var' Input of this 'ResourceApplyAdam' operation.
    pub fn var(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'm' Input of this 'ResourceApplyAdam' operation.
    pub fn m(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'v' Input of this 'ResourceApplyAdam' operation.
    pub fn v(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'beta1_power' Input of this 'ResourceApplyAdam' operation.
    pub fn beta1_power(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'beta2_power' Input of this 'ResourceApplyAdam' operation.
    pub fn beta2_power(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
    /// Returns the 'lr' Input of this 'ResourceApplyAdam' operation.
    pub fn lr(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 5,
        }
    }
    /// Returns the 'beta1' Input of this 'ResourceApplyAdam' operation.
    pub fn beta1(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 6,
        }
    }
    /// Returns the 'beta2' Input of this 'ResourceApplyAdam' operation.
    pub fn beta2(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 7,
        }
    }
    /// Returns the 'epsilon' Input of this 'ResourceApplyAdam' operation.
    pub fn epsilon(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 8,
        }
    }
    /// Returns the 'grad' Input of this 'ResourceApplyAdam' operation.
    pub fn grad(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 9,
        }
    }
}
impl From<ResourceApplyAdamInst> for crate::Operation {
    fn from(inst: ResourceApplyAdamInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ResourceApplyAdam::new().build(var, m, v, beta1_power, beta2_power, lr, beta1, beta2, epsilon, grad, scope)`.
pub fn resource_apply_adam<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
    O6: ::std::convert::Into<crate::Output>,
    O7: ::std::convert::Into<crate::Output>,
    O8: ::std::convert::Into<crate::Output>,
    O9: ::std::convert::Into<crate::Output>,
>(
    var: O0,
    m: O1,
    v: O2,
    beta1_power: O3,
    beta2_power: O4,
    lr: O5,
    beta1: O6,
    beta2: O7,
    epsilon: O8,
    grad: O9,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ResourceApplyAdam::new().build(
        var,
        m,
        v,
        beta1_power,
        beta2_power,
        lr,
        beta1,
        beta2,
        epsilon,
        grad,
        scope,
    )
}

/// Builder for the `ResourceApplyAdamWithAmsgrad` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ResourceApplyAdamWithAmsgrad {
    T: ::std::option::Option<crate::DataType>,
    use_locking: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ResourceApplyAdamWithAmsgrad' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ResourceApplyAdamWithAmsgradInst {
    /// An instance of a fully built ResourceApplyAdamWithAmsgrad Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ResourceApplyAdamWithAmsgrad {
    /// Creates a new `ResourceApplyAdamWithAmsgrad`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_locking` attribute.
    pub fn use_locking<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.use_locking = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ResourceApplyAdamWithAmsgrad` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
        O6: ::std::convert::Into<crate::Output>,
        O7: ::std::convert::Into<crate::Output>,
        O8: ::std::convert::Into<crate::Output>,
        O9: ::std::convert::Into<crate::Output>,
        O10: ::std::convert::Into<crate::Output>,
    >(
        &self,
        var: O0,
        m: O1,
        v: O2,
        vhat: O3,
        beta1_power: O4,
        beta2_power: O5,
        lr: O6,
        beta1: O7,
        beta2: O8,
        epsilon: O9,
        grad: O10,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            var.into(),
            m.into(),
            v.into(),
            vhat.into(),
            beta1_power.into(),
            beta2_power.into(),
            lr.into(),
            beta1.into(),
            beta2.into(),
            epsilon.into(),
            grad.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        var: crate::Output,
        m: crate::Output,
        v: crate::Output,
        vhat: crate::Output,
        beta1_power: crate::Output,
        beta2_power: crate::Output,
        lr: crate::Output,
        beta1: crate::Output,
        beta2: crate::Output,
        epsilon: crate::Output,
        grad: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ResourceApplyAdamWithAmsgrad", |nd| {
            nd.add_input(var);
            nd.add_input(m);
            nd.add_input(v);
            nd.add_input(vhat);
            nd.add_input(beta1_power);
            nd.add_input(beta2_power);
            nd.add_input(lr);
            nd.add_input(beta1);
            nd.add_input(beta2);
            nd.add_input(epsilon);
            nd.add_input(grad);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                nd.set_attr_bool("use_locking", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ResourceApplyAdamWithAmsgrad' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        var: crate::Output,
        m: crate::Output,
        v: crate::Output,
        vhat: crate::Output,
        beta1_power: crate::Output,
        beta2_power: crate::Output,
        lr: crate::Output,
        beta1: crate::Output,
        beta2: crate::Output,
        epsilon: crate::Output,
        grad: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ResourceApplyAdamWithAmsgradInst> {
        let op = scope.new_operation("ResourceApplyAdamWithAmsgrad", |builder| {
            builder.add_input(var);
            builder.add_input(m);
            builder.add_input(v);
            builder.add_input(vhat);
            builder.add_input(beta1_power);
            builder.add_input(beta2_power);
            builder.add_input(lr);
            builder.add_input(beta1);
            builder.add_input(beta2);
            builder.add_input(epsilon);
            builder.add_input(grad);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                builder.set_attr_bool("use_locking", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ResourceApplyAdamWithAmsgradInst { op })
    }
}
impl ResourceApplyAdamWithAmsgradInst {
    /// Returns the 'var' Input of this 'ResourceApplyAdamWithAmsgrad' operation.
    pub fn var(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'm' Input of this 'ResourceApplyAdamWithAmsgrad' operation.
    pub fn m(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'v' Input of this 'ResourceApplyAdamWithAmsgrad' operation.
    pub fn v(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'vhat' Input of this 'ResourceApplyAdamWithAmsgrad' operation.
    pub fn vhat(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'beta1_power' Input of this 'ResourceApplyAdamWithAmsgrad' operation.
    pub fn beta1_power(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
    /// Returns the 'beta2_power' Input of this 'ResourceApplyAdamWithAmsgrad' operation.
    pub fn beta2_power(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 5,
        }
    }
    /// Returns the 'lr' Input of this 'ResourceApplyAdamWithAmsgrad' operation.
    pub fn lr(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 6,
        }
    }
    /// Returns the 'beta1' Input of this 'ResourceApplyAdamWithAmsgrad' operation.
    pub fn beta1(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 7,
        }
    }
    /// Returns the 'beta2' Input of this 'ResourceApplyAdamWithAmsgrad' operation.
    pub fn beta2(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 8,
        }
    }
    /// Returns the 'epsilon' Input of this 'ResourceApplyAdamWithAmsgrad' operation.
    pub fn epsilon(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 9,
        }
    }
    /// Returns the 'grad' Input of this 'ResourceApplyAdamWithAmsgrad' operation.
    pub fn grad(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 10,
        }
    }
}
impl From<ResourceApplyAdamWithAmsgradInst> for crate::Operation {
    fn from(inst: ResourceApplyAdamWithAmsgradInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ResourceApplyAdamWithAmsgrad::new().build(var, m, v, vhat, beta1_power, beta2_power, lr, beta1, beta2, epsilon, grad, scope)`.
pub fn resource_apply_adam_with_amsgrad<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
    O6: ::std::convert::Into<crate::Output>,
    O7: ::std::convert::Into<crate::Output>,
    O8: ::std::convert::Into<crate::Output>,
    O9: ::std::convert::Into<crate::Output>,
    O10: ::std::convert::Into<crate::Output>,
>(
    var: O0,
    m: O1,
    v: O2,
    vhat: O3,
    beta1_power: O4,
    beta2_power: O5,
    lr: O6,
    beta1: O7,
    beta2: O8,
    epsilon: O9,
    grad: O10,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ResourceApplyAdamWithAmsgrad::new().build(
        var,
        m,
        v,
        vhat,
        beta1_power,
        beta2_power,
        lr,
        beta1,
        beta2,
        epsilon,
        grad,
        scope,
    )
}

/// Builder for the `ResourceApplyAddSign` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ResourceApplyAddSign {
    T: ::std::option::Option<crate::DataType>,
    use_locking: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ResourceApplyAddSign' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ResourceApplyAddSignInst {
    /// An instance of a fully built ResourceApplyAddSign Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ResourceApplyAddSign {
    /// Creates a new `ResourceApplyAddSign`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_locking` attribute.
    pub fn use_locking<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.use_locking = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ResourceApplyAddSign` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
        O6: ::std::convert::Into<crate::Output>,
    >(
        &self,
        var: O0,
        m: O1,
        lr: O2,
        alpha: O3,
        sign_decay: O4,
        beta: O5,
        grad: O6,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            var.into(),
            m.into(),
            lr.into(),
            alpha.into(),
            sign_decay.into(),
            beta.into(),
            grad.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        var: crate::Output,
        m: crate::Output,
        lr: crate::Output,
        alpha: crate::Output,
        sign_decay: crate::Output,
        beta: crate::Output,
        grad: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ResourceApplyAddSign", |nd| {
            nd.add_input(var);
            nd.add_input(m);
            nd.add_input(lr);
            nd.add_input(alpha);
            nd.add_input(sign_decay);
            nd.add_input(beta);
            nd.add_input(grad);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                nd.set_attr_bool("use_locking", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ResourceApplyAddSign' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        var: crate::Output,
        m: crate::Output,
        lr: crate::Output,
        alpha: crate::Output,
        sign_decay: crate::Output,
        beta: crate::Output,
        grad: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ResourceApplyAddSignInst> {
        let op = scope.new_operation("ResourceApplyAddSign", |builder| {
            builder.add_input(var);
            builder.add_input(m);
            builder.add_input(lr);
            builder.add_input(alpha);
            builder.add_input(sign_decay);
            builder.add_input(beta);
            builder.add_input(grad);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                builder.set_attr_bool("use_locking", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ResourceApplyAddSignInst { op })
    }
}
impl ResourceApplyAddSignInst {
    /// Returns the 'var' Input of this 'ResourceApplyAddSign' operation.
    pub fn var(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'm' Input of this 'ResourceApplyAddSign' operation.
    pub fn m(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'lr' Input of this 'ResourceApplyAddSign' operation.
    pub fn lr(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'alpha' Input of this 'ResourceApplyAddSign' operation.
    pub fn alpha(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'sign_decay' Input of this 'ResourceApplyAddSign' operation.
    pub fn sign_decay(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
    /// Returns the 'beta' Input of this 'ResourceApplyAddSign' operation.
    pub fn beta(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 5,
        }
    }
    /// Returns the 'grad' Input of this 'ResourceApplyAddSign' operation.
    pub fn grad(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 6,
        }
    }
}
impl From<ResourceApplyAddSignInst> for crate::Operation {
    fn from(inst: ResourceApplyAddSignInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ResourceApplyAddSign::new().build(var, m, lr, alpha, sign_decay, beta, grad, scope)`.
pub fn resource_apply_add_sign<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
    O6: ::std::convert::Into<crate::Output>,
>(
    var: O0,
    m: O1,
    lr: O2,
    alpha: O3,
    sign_decay: O4,
    beta: O5,
    grad: O6,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ResourceApplyAddSign::new().build(var, m, lr, alpha, sign_decay, beta, grad, scope)
}

/// Builder for the `ResourceApplyCenteredRMSProp` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ResourceApplyCenteredRMSProp {
    T: ::std::option::Option<crate::DataType>,
    use_locking: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ResourceApplyCenteredRMSProp' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ResourceApplyCenteredRMSPropInst {
    /// An instance of a fully built ResourceApplyCenteredRMSProp Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ResourceApplyCenteredRMSProp {
    /// Creates a new `ResourceApplyCenteredRMSProp`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_locking` attribute.
    pub fn use_locking<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.use_locking = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ResourceApplyCenteredRMSProp` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
        O6: ::std::convert::Into<crate::Output>,
        O7: ::std::convert::Into<crate::Output>,
        O8: ::std::convert::Into<crate::Output>,
    >(
        &self,
        var: O0,
        mg: O1,
        ms: O2,
        mom: O3,
        lr: O4,
        rho: O5,
        momentum: O6,
        epsilon: O7,
        grad: O8,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            var.into(),
            mg.into(),
            ms.into(),
            mom.into(),
            lr.into(),
            rho.into(),
            momentum.into(),
            epsilon.into(),
            grad.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        var: crate::Output,
        mg: crate::Output,
        ms: crate::Output,
        mom: crate::Output,
        lr: crate::Output,
        rho: crate::Output,
        momentum: crate::Output,
        epsilon: crate::Output,
        grad: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ResourceApplyCenteredRMSProp", |nd| {
            nd.add_input(var);
            nd.add_input(mg);
            nd.add_input(ms);
            nd.add_input(mom);
            nd.add_input(lr);
            nd.add_input(rho);
            nd.add_input(momentum);
            nd.add_input(epsilon);
            nd.add_input(grad);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                nd.set_attr_bool("use_locking", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ResourceApplyCenteredRMSProp' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        var: crate::Output,
        mg: crate::Output,
        ms: crate::Output,
        mom: crate::Output,
        lr: crate::Output,
        rho: crate::Output,
        momentum: crate::Output,
        epsilon: crate::Output,
        grad: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ResourceApplyCenteredRMSPropInst> {
        let op = scope.new_operation("ResourceApplyCenteredRMSProp", |builder| {
            builder.add_input(var);
            builder.add_input(mg);
            builder.add_input(ms);
            builder.add_input(mom);
            builder.add_input(lr);
            builder.add_input(rho);
            builder.add_input(momentum);
            builder.add_input(epsilon);
            builder.add_input(grad);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                builder.set_attr_bool("use_locking", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ResourceApplyCenteredRMSPropInst { op })
    }
}
impl ResourceApplyCenteredRMSPropInst {
    /// Returns the 'var' Input of this 'ResourceApplyCenteredRMSProp' operation.
    pub fn var(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'mg' Input of this 'ResourceApplyCenteredRMSProp' operation.
    pub fn mg(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'ms' Input of this 'ResourceApplyCenteredRMSProp' operation.
    pub fn ms(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'mom' Input of this 'ResourceApplyCenteredRMSProp' operation.
    pub fn mom(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'lr' Input of this 'ResourceApplyCenteredRMSProp' operation.
    pub fn lr(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
    /// Returns the 'rho' Input of this 'ResourceApplyCenteredRMSProp' operation.
    pub fn rho(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 5,
        }
    }
    /// Returns the 'momentum' Input of this 'ResourceApplyCenteredRMSProp' operation.
    pub fn momentum(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 6,
        }
    }
    /// Returns the 'epsilon' Input of this 'ResourceApplyCenteredRMSProp' operation.
    pub fn epsilon(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 7,
        }
    }
    /// Returns the 'grad' Input of this 'ResourceApplyCenteredRMSProp' operation.
    pub fn grad(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 8,
        }
    }
}
impl From<ResourceApplyCenteredRMSPropInst> for crate::Operation {
    fn from(inst: ResourceApplyCenteredRMSPropInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ResourceApplyCenteredRMSProp::new().build(var, mg, ms, mom, lr, rho, momentum, epsilon, grad, scope)`.
pub fn resource_apply_centered_rmsprop<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
    O6: ::std::convert::Into<crate::Output>,
    O7: ::std::convert::Into<crate::Output>,
    O8: ::std::convert::Into<crate::Output>,
>(
    var: O0,
    mg: O1,
    ms: O2,
    mom: O3,
    lr: O4,
    rho: O5,
    momentum: O6,
    epsilon: O7,
    grad: O8,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ResourceApplyCenteredRMSProp::new()
        .build(var, mg, ms, mom, lr, rho, momentum, epsilon, grad, scope)
}

/// Builder for the `ResourceApplyFtrl` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ResourceApplyFtrl {
    T: ::std::option::Option<crate::DataType>,
    use_locking: ::std::option::Option<bool>,
    multiply_linear_by_lr: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ResourceApplyFtrl' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ResourceApplyFtrlInst {
    /// An instance of a fully built ResourceApplyFtrl Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ResourceApplyFtrl {
    /// Creates a new `ResourceApplyFtrl`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_locking` attribute.
    pub fn use_locking<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.use_locking = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `multiply_linear_by_lr` attribute.
    pub fn multiply_linear_by_lr<ArgType: ::std::convert::Into<bool>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.multiply_linear_by_lr = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ResourceApplyFtrl` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
        O6: ::std::convert::Into<crate::Output>,
        O7: ::std::convert::Into<crate::Output>,
    >(
        &self,
        var: O0,
        accum: O1,
        linear: O2,
        grad: O3,
        lr: O4,
        l1: O5,
        l2: O6,
        lr_power: O7,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            var.into(),
            accum.into(),
            linear.into(),
            grad.into(),
            lr.into(),
            l1.into(),
            l2.into(),
            lr_power.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        var: crate::Output,
        accum: crate::Output,
        linear: crate::Output,
        grad: crate::Output,
        lr: crate::Output,
        l1: crate::Output,
        l2: crate::Output,
        lr_power: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ResourceApplyFtrl", |nd| {
            nd.add_input(var);
            nd.add_input(accum);
            nd.add_input(linear);
            nd.add_input(grad);
            nd.add_input(lr);
            nd.add_input(l1);
            nd.add_input(l2);
            nd.add_input(lr_power);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                nd.set_attr_bool("use_locking", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.multiply_linear_by_lr {
                nd.set_attr_bool("multiply_linear_by_lr", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ResourceApplyFtrl' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        var: crate::Output,
        accum: crate::Output,
        linear: crate::Output,
        grad: crate::Output,
        lr: crate::Output,
        l1: crate::Output,
        l2: crate::Output,
        lr_power: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ResourceApplyFtrlInst> {
        let op = scope.new_operation("ResourceApplyFtrl", |builder| {
            builder.add_input(var);
            builder.add_input(accum);
            builder.add_input(linear);
            builder.add_input(grad);
            builder.add_input(lr);
            builder.add_input(l1);
            builder.add_input(l2);
            builder.add_input(lr_power);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                builder.set_attr_bool("use_locking", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.multiply_linear_by_lr {
                builder.set_attr_bool("multiply_linear_by_lr", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ResourceApplyFtrlInst { op })
    }
}
impl ResourceApplyFtrlInst {
    /// Returns the 'var' Input of this 'ResourceApplyFtrl' operation.
    pub fn var(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'accum' Input of this 'ResourceApplyFtrl' operation.
    pub fn accum(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'linear' Input of this 'ResourceApplyFtrl' operation.
    pub fn linear(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'grad' Input of this 'ResourceApplyFtrl' operation.
    pub fn grad(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'lr' Input of this 'ResourceApplyFtrl' operation.
    pub fn lr(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
    /// Returns the 'l1' Input of this 'ResourceApplyFtrl' operation.
    pub fn l1(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 5,
        }
    }
    /// Returns the 'l2' Input of this 'ResourceApplyFtrl' operation.
    pub fn l2(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 6,
        }
    }
    /// Returns the 'lr_power' Input of this 'ResourceApplyFtrl' operation.
    pub fn lr_power(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 7,
        }
    }
}
impl From<ResourceApplyFtrlInst> for crate::Operation {
    fn from(inst: ResourceApplyFtrlInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ResourceApplyFtrl::new().build(var, accum, linear, grad, lr, l1, l2, lr_power, scope)`.
pub fn resource_apply_ftrl<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
    O6: ::std::convert::Into<crate::Output>,
    O7: ::std::convert::Into<crate::Output>,
>(
    var: O0,
    accum: O1,
    linear: O2,
    grad: O3,
    lr: O4,
    l1: O5,
    l2: O6,
    lr_power: O7,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ResourceApplyFtrl::new().build(var, accum, linear, grad, lr, l1, l2, lr_power, scope)
}

/// Builder for the `ResourceApplyFtrlV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ResourceApplyFtrlV2 {
    T: ::std::option::Option<crate::DataType>,
    use_locking: ::std::option::Option<bool>,
    multiply_linear_by_lr: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ResourceApplyFtrlV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ResourceApplyFtrlV2Inst {
    /// An instance of a fully built ResourceApplyFtrlV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ResourceApplyFtrlV2 {
    /// Creates a new `ResourceApplyFtrlV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_locking` attribute.
    pub fn use_locking<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.use_locking = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `multiply_linear_by_lr` attribute.
    pub fn multiply_linear_by_lr<ArgType: ::std::convert::Into<bool>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.multiply_linear_by_lr = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ResourceApplyFtrlV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
        O6: ::std::convert::Into<crate::Output>,
        O7: ::std::convert::Into<crate::Output>,
        O8: ::std::convert::Into<crate::Output>,
    >(
        &self,
        var: O0,
        accum: O1,
        linear: O2,
        grad: O3,
        lr: O4,
        l1: O5,
        l2: O6,
        l2_shrinkage: O7,
        lr_power: O8,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            var.into(),
            accum.into(),
            linear.into(),
            grad.into(),
            lr.into(),
            l1.into(),
            l2.into(),
            l2_shrinkage.into(),
            lr_power.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        var: crate::Output,
        accum: crate::Output,
        linear: crate::Output,
        grad: crate::Output,
        lr: crate::Output,
        l1: crate::Output,
        l2: crate::Output,
        l2_shrinkage: crate::Output,
        lr_power: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ResourceApplyFtrlV2", |nd| {
            nd.add_input(var);
            nd.add_input(accum);
            nd.add_input(linear);
            nd.add_input(grad);
            nd.add_input(lr);
            nd.add_input(l1);
            nd.add_input(l2);
            nd.add_input(l2_shrinkage);
            nd.add_input(lr_power);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                nd.set_attr_bool("use_locking", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.multiply_linear_by_lr {
                nd.set_attr_bool("multiply_linear_by_lr", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ResourceApplyFtrlV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        var: crate::Output,
        accum: crate::Output,
        linear: crate::Output,
        grad: crate::Output,
        lr: crate::Output,
        l1: crate::Output,
        l2: crate::Output,
        l2_shrinkage: crate::Output,
        lr_power: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ResourceApplyFtrlV2Inst> {
        let op = scope.new_operation("ResourceApplyFtrlV2", |builder| {
            builder.add_input(var);
            builder.add_input(accum);
            builder.add_input(linear);
            builder.add_input(grad);
            builder.add_input(lr);
            builder.add_input(l1);
            builder.add_input(l2);
            builder.add_input(l2_shrinkage);
            builder.add_input(lr_power);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                builder.set_attr_bool("use_locking", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.multiply_linear_by_lr {
                builder.set_attr_bool("multiply_linear_by_lr", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ResourceApplyFtrlV2Inst { op })
    }
}
impl ResourceApplyFtrlV2Inst {
    /// Returns the 'var' Input of this 'ResourceApplyFtrlV2' operation.
    pub fn var(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'accum' Input of this 'ResourceApplyFtrlV2' operation.
    pub fn accum(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'linear' Input of this 'ResourceApplyFtrlV2' operation.
    pub fn linear(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'grad' Input of this 'ResourceApplyFtrlV2' operation.
    pub fn grad(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'lr' Input of this 'ResourceApplyFtrlV2' operation.
    pub fn lr(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
    /// Returns the 'l1' Input of this 'ResourceApplyFtrlV2' operation.
    pub fn l1(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 5,
        }
    }
    /// Returns the 'l2' Input of this 'ResourceApplyFtrlV2' operation.
    pub fn l2(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 6,
        }
    }
    /// Returns the 'l2_shrinkage' Input of this 'ResourceApplyFtrlV2' operation.
    pub fn l2_shrinkage(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 7,
        }
    }
    /// Returns the 'lr_power' Input of this 'ResourceApplyFtrlV2' operation.
    pub fn lr_power(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 8,
        }
    }
}
impl From<ResourceApplyFtrlV2Inst> for crate::Operation {
    fn from(inst: ResourceApplyFtrlV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ResourceApplyFtrlV2::new().build(var, accum, linear, grad, lr, l1, l2, l2_shrinkage, lr_power, scope)`.
pub fn resource_apply_ftrl_v2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
    O6: ::std::convert::Into<crate::Output>,
    O7: ::std::convert::Into<crate::Output>,
    O8: ::std::convert::Into<crate::Output>,
>(
    var: O0,
    accum: O1,
    linear: O2,
    grad: O3,
    lr: O4,
    l1: O5,
    l2: O6,
    l2_shrinkage: O7,
    lr_power: O8,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ResourceApplyFtrlV2::new().build(
        var,
        accum,
        linear,
        grad,
        lr,
        l1,
        l2,
        l2_shrinkage,
        lr_power,
        scope,
    )
}

/// Builder for the `ResourceApplyGradientDescent` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ResourceApplyGradientDescent {
    T: ::std::option::Option<crate::DataType>,
    use_locking: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ResourceApplyGradientDescent' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ResourceApplyGradientDescentInst {
    /// An instance of a fully built ResourceApplyGradientDescent Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ResourceApplyGradientDescent {
    /// Creates a new `ResourceApplyGradientDescent`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_locking` attribute.
    pub fn use_locking<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.use_locking = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ResourceApplyGradientDescent` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        var: O0,
        alpha: O1,
        delta: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(var.into(), alpha.into(), delta.into(), scope)
    }
    fn build_impl(
        &self,
        var: crate::Output,
        alpha: crate::Output,
        delta: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ResourceApplyGradientDescent", |nd| {
            nd.add_input(var);
            nd.add_input(alpha);
            nd.add_input(delta);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                nd.set_attr_bool("use_locking", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ResourceApplyGradientDescent' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        var: crate::Output,
        alpha: crate::Output,
        delta: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ResourceApplyGradientDescentInst> {
        let op = scope.new_operation("ResourceApplyGradientDescent", |builder| {
            builder.add_input(var);
            builder.add_input(alpha);
            builder.add_input(delta);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                builder.set_attr_bool("use_locking", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ResourceApplyGradientDescentInst { op })
    }
}
impl ResourceApplyGradientDescentInst {
    /// Returns the 'var' Input of this 'ResourceApplyGradientDescent' operation.
    pub fn var(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'alpha' Input of this 'ResourceApplyGradientDescent' operation.
    pub fn alpha(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'delta' Input of this 'ResourceApplyGradientDescent' operation.
    pub fn delta(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<ResourceApplyGradientDescentInst> for crate::Operation {
    fn from(inst: ResourceApplyGradientDescentInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ResourceApplyGradientDescent::new().build(var, alpha, delta, scope)`.
pub fn resource_apply_gradient_descent<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    var: O0,
    alpha: O1,
    delta: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ResourceApplyGradientDescent::new().build(var, alpha, delta, scope)
}

/// Builder for the `ResourceApplyKerasMomentum` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ResourceApplyKerasMomentum {
    T: ::std::option::Option<crate::DataType>,
    use_locking: ::std::option::Option<bool>,
    use_nesterov: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ResourceApplyKerasMomentum' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ResourceApplyKerasMomentumInst {
    /// An instance of a fully built ResourceApplyKerasMomentum Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ResourceApplyKerasMomentum {
    /// Creates a new `ResourceApplyKerasMomentum`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_locking` attribute.
    pub fn use_locking<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.use_locking = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_nesterov` attribute.
    pub fn use_nesterov<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.use_nesterov = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ResourceApplyKerasMomentum` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
    >(
        &self,
        var: O0,
        accum: O1,
        lr: O2,
        grad: O3,
        momentum: O4,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            var.into(),
            accum.into(),
            lr.into(),
            grad.into(),
            momentum.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        var: crate::Output,
        accum: crate::Output,
        lr: crate::Output,
        grad: crate::Output,
        momentum: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ResourceApplyKerasMomentum", |nd| {
            nd.add_input(var);
            nd.add_input(accum);
            nd.add_input(lr);
            nd.add_input(grad);
            nd.add_input(momentum);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                nd.set_attr_bool("use_locking", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_nesterov {
                nd.set_attr_bool("use_nesterov", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ResourceApplyKerasMomentum' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        var: crate::Output,
        accum: crate::Output,
        lr: crate::Output,
        grad: crate::Output,
        momentum: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ResourceApplyKerasMomentumInst> {
        let op = scope.new_operation("ResourceApplyKerasMomentum", |builder| {
            builder.add_input(var);
            builder.add_input(accum);
            builder.add_input(lr);
            builder.add_input(grad);
            builder.add_input(momentum);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                builder.set_attr_bool("use_locking", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_nesterov {
                builder.set_attr_bool("use_nesterov", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ResourceApplyKerasMomentumInst { op })
    }
}
impl ResourceApplyKerasMomentumInst {
    /// Returns the 'var' Input of this 'ResourceApplyKerasMomentum' operation.
    pub fn var(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'accum' Input of this 'ResourceApplyKerasMomentum' operation.
    pub fn accum(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'lr' Input of this 'ResourceApplyKerasMomentum' operation.
    pub fn lr(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'grad' Input of this 'ResourceApplyKerasMomentum' operation.
    pub fn grad(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'momentum' Input of this 'ResourceApplyKerasMomentum' operation.
    pub fn momentum(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
}
impl From<ResourceApplyKerasMomentumInst> for crate::Operation {
    fn from(inst: ResourceApplyKerasMomentumInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ResourceApplyKerasMomentum::new().build(var, accum, lr, grad, momentum, scope)`.
pub fn resource_apply_keras_momentum<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
>(
    var: O0,
    accum: O1,
    lr: O2,
    grad: O3,
    momentum: O4,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ResourceApplyKerasMomentum::new().build(var, accum, lr, grad, momentum, scope)
}

/// Builder for the `ResourceApplyMomentum` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ResourceApplyMomentum {
    T: ::std::option::Option<crate::DataType>,
    use_locking: ::std::option::Option<bool>,
    use_nesterov: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ResourceApplyMomentum' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ResourceApplyMomentumInst {
    /// An instance of a fully built ResourceApplyMomentum Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ResourceApplyMomentum {
    /// Creates a new `ResourceApplyMomentum`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_locking` attribute.
    pub fn use_locking<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.use_locking = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_nesterov` attribute.
    pub fn use_nesterov<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.use_nesterov = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ResourceApplyMomentum` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
    >(
        &self,
        var: O0,
        accum: O1,
        lr: O2,
        grad: O3,
        momentum: O4,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            var.into(),
            accum.into(),
            lr.into(),
            grad.into(),
            momentum.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        var: crate::Output,
        accum: crate::Output,
        lr: crate::Output,
        grad: crate::Output,
        momentum: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ResourceApplyMomentum", |nd| {
            nd.add_input(var);
            nd.add_input(accum);
            nd.add_input(lr);
            nd.add_input(grad);
            nd.add_input(momentum);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                nd.set_attr_bool("use_locking", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_nesterov {
                nd.set_attr_bool("use_nesterov", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ResourceApplyMomentum' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        var: crate::Output,
        accum: crate::Output,
        lr: crate::Output,
        grad: crate::Output,
        momentum: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ResourceApplyMomentumInst> {
        let op = scope.new_operation("ResourceApplyMomentum", |builder| {
            builder.add_input(var);
            builder.add_input(accum);
            builder.add_input(lr);
            builder.add_input(grad);
            builder.add_input(momentum);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                builder.set_attr_bool("use_locking", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_nesterov {
                builder.set_attr_bool("use_nesterov", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ResourceApplyMomentumInst { op })
    }
}
impl ResourceApplyMomentumInst {
    /// Returns the 'var' Input of this 'ResourceApplyMomentum' operation.
    pub fn var(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'accum' Input of this 'ResourceApplyMomentum' operation.
    pub fn accum(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'lr' Input of this 'ResourceApplyMomentum' operation.
    pub fn lr(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'grad' Input of this 'ResourceApplyMomentum' operation.
    pub fn grad(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'momentum' Input of this 'ResourceApplyMomentum' operation.
    pub fn momentum(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
}
impl From<ResourceApplyMomentumInst> for crate::Operation {
    fn from(inst: ResourceApplyMomentumInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ResourceApplyMomentum::new().build(var, accum, lr, grad, momentum, scope)`.
pub fn resource_apply_momentum<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
>(
    var: O0,
    accum: O1,
    lr: O2,
    grad: O3,
    momentum: O4,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ResourceApplyMomentum::new().build(var, accum, lr, grad, momentum, scope)
}

/// Builder for the `ResourceApplyPowerSign` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ResourceApplyPowerSign {
    T: ::std::option::Option<crate::DataType>,
    use_locking: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ResourceApplyPowerSign' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ResourceApplyPowerSignInst {
    /// An instance of a fully built ResourceApplyPowerSign Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ResourceApplyPowerSign {
    /// Creates a new `ResourceApplyPowerSign`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_locking` attribute.
    pub fn use_locking<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.use_locking = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ResourceApplyPowerSign` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
        O6: ::std::convert::Into<crate::Output>,
    >(
        &self,
        var: O0,
        m: O1,
        lr: O2,
        logbase: O3,
        sign_decay: O4,
        beta: O5,
        grad: O6,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            var.into(),
            m.into(),
            lr.into(),
            logbase.into(),
            sign_decay.into(),
            beta.into(),
            grad.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        var: crate::Output,
        m: crate::Output,
        lr: crate::Output,
        logbase: crate::Output,
        sign_decay: crate::Output,
        beta: crate::Output,
        grad: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ResourceApplyPowerSign", |nd| {
            nd.add_input(var);
            nd.add_input(m);
            nd.add_input(lr);
            nd.add_input(logbase);
            nd.add_input(sign_decay);
            nd.add_input(beta);
            nd.add_input(grad);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                nd.set_attr_bool("use_locking", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ResourceApplyPowerSign' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        var: crate::Output,
        m: crate::Output,
        lr: crate::Output,
        logbase: crate::Output,
        sign_decay: crate::Output,
        beta: crate::Output,
        grad: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ResourceApplyPowerSignInst> {
        let op = scope.new_operation("ResourceApplyPowerSign", |builder| {
            builder.add_input(var);
            builder.add_input(m);
            builder.add_input(lr);
            builder.add_input(logbase);
            builder.add_input(sign_decay);
            builder.add_input(beta);
            builder.add_input(grad);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                builder.set_attr_bool("use_locking", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ResourceApplyPowerSignInst { op })
    }
}
impl ResourceApplyPowerSignInst {
    /// Returns the 'var' Input of this 'ResourceApplyPowerSign' operation.
    pub fn var(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'm' Input of this 'ResourceApplyPowerSign' operation.
    pub fn m(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'lr' Input of this 'ResourceApplyPowerSign' operation.
    pub fn lr(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'logbase' Input of this 'ResourceApplyPowerSign' operation.
    pub fn logbase(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'sign_decay' Input of this 'ResourceApplyPowerSign' operation.
    pub fn sign_decay(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
    /// Returns the 'beta' Input of this 'ResourceApplyPowerSign' operation.
    pub fn beta(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 5,
        }
    }
    /// Returns the 'grad' Input of this 'ResourceApplyPowerSign' operation.
    pub fn grad(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 6,
        }
    }
}
impl From<ResourceApplyPowerSignInst> for crate::Operation {
    fn from(inst: ResourceApplyPowerSignInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ResourceApplyPowerSign::new().build(var, m, lr, logbase, sign_decay, beta, grad, scope)`.
pub fn resource_apply_power_sign<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
    O6: ::std::convert::Into<crate::Output>,
>(
    var: O0,
    m: O1,
    lr: O2,
    logbase: O3,
    sign_decay: O4,
    beta: O5,
    grad: O6,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ResourceApplyPowerSign::new().build(var, m, lr, logbase, sign_decay, beta, grad, scope)
}

/// Builder for the `ResourceApplyProximalAdagrad` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ResourceApplyProximalAdagrad {
    T: ::std::option::Option<crate::DataType>,
    use_locking: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ResourceApplyProximalAdagrad' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ResourceApplyProximalAdagradInst {
    /// An instance of a fully built ResourceApplyProximalAdagrad Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ResourceApplyProximalAdagrad {
    /// Creates a new `ResourceApplyProximalAdagrad`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_locking` attribute.
    pub fn use_locking<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.use_locking = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ResourceApplyProximalAdagrad` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
    >(
        &self,
        var: O0,
        accum: O1,
        lr: O2,
        l1: O3,
        l2: O4,
        grad: O5,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            var.into(),
            accum.into(),
            lr.into(),
            l1.into(),
            l2.into(),
            grad.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        var: crate::Output,
        accum: crate::Output,
        lr: crate::Output,
        l1: crate::Output,
        l2: crate::Output,
        grad: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ResourceApplyProximalAdagrad", |nd| {
            nd.add_input(var);
            nd.add_input(accum);
            nd.add_input(lr);
            nd.add_input(l1);
            nd.add_input(l2);
            nd.add_input(grad);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                nd.set_attr_bool("use_locking", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ResourceApplyProximalAdagrad' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        var: crate::Output,
        accum: crate::Output,
        lr: crate::Output,
        l1: crate::Output,
        l2: crate::Output,
        grad: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ResourceApplyProximalAdagradInst> {
        let op = scope.new_operation("ResourceApplyProximalAdagrad", |builder| {
            builder.add_input(var);
            builder.add_input(accum);
            builder.add_input(lr);
            builder.add_input(l1);
            builder.add_input(l2);
            builder.add_input(grad);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                builder.set_attr_bool("use_locking", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ResourceApplyProximalAdagradInst { op })
    }
}
impl ResourceApplyProximalAdagradInst {
    /// Returns the 'var' Input of this 'ResourceApplyProximalAdagrad' operation.
    pub fn var(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'accum' Input of this 'ResourceApplyProximalAdagrad' operation.
    pub fn accum(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'lr' Input of this 'ResourceApplyProximalAdagrad' operation.
    pub fn lr(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'l1' Input of this 'ResourceApplyProximalAdagrad' operation.
    pub fn l1(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'l2' Input of this 'ResourceApplyProximalAdagrad' operation.
    pub fn l2(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
    /// Returns the 'grad' Input of this 'ResourceApplyProximalAdagrad' operation.
    pub fn grad(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 5,
        }
    }
}
impl From<ResourceApplyProximalAdagradInst> for crate::Operation {
    fn from(inst: ResourceApplyProximalAdagradInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ResourceApplyProximalAdagrad::new().build(var, accum, lr, l1, l2, grad, scope)`.
pub fn resource_apply_proximal_adagrad<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
>(
    var: O0,
    accum: O1,
    lr: O2,
    l1: O3,
    l2: O4,
    grad: O5,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ResourceApplyProximalAdagrad::new().build(var, accum, lr, l1, l2, grad, scope)
}

/// Builder for the `ResourceApplyProximalGradientDescent` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ResourceApplyProximalGradientDescent {
    T: ::std::option::Option<crate::DataType>,
    use_locking: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ResourceApplyProximalGradientDescent' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ResourceApplyProximalGradientDescentInst {
    /// An instance of a fully built ResourceApplyProximalGradientDescent Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ResourceApplyProximalGradientDescent {
    /// Creates a new `ResourceApplyProximalGradientDescent`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_locking` attribute.
    pub fn use_locking<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.use_locking = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ResourceApplyProximalGradientDescent` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
    >(
        &self,
        var: O0,
        alpha: O1,
        l1: O2,
        l2: O3,
        delta: O4,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            var.into(),
            alpha.into(),
            l1.into(),
            l2.into(),
            delta.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        var: crate::Output,
        alpha: crate::Output,
        l1: crate::Output,
        l2: crate::Output,
        delta: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ResourceApplyProximalGradientDescent", |nd| {
            nd.add_input(var);
            nd.add_input(alpha);
            nd.add_input(l1);
            nd.add_input(l2);
            nd.add_input(delta);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                nd.set_attr_bool("use_locking", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ResourceApplyProximalGradientDescent' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        var: crate::Output,
        alpha: crate::Output,
        l1: crate::Output,
        l2: crate::Output,
        delta: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ResourceApplyProximalGradientDescentInst> {
        let op = scope.new_operation("ResourceApplyProximalGradientDescent", |builder| {
            builder.add_input(var);
            builder.add_input(alpha);
            builder.add_input(l1);
            builder.add_input(l2);
            builder.add_input(delta);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                builder.set_attr_bool("use_locking", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ResourceApplyProximalGradientDescentInst { op })
    }
}
impl ResourceApplyProximalGradientDescentInst {
    /// Returns the 'var' Input of this 'ResourceApplyProximalGradientDescent' operation.
    pub fn var(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'alpha' Input of this 'ResourceApplyProximalGradientDescent' operation.
    pub fn alpha(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'l1' Input of this 'ResourceApplyProximalGradientDescent' operation.
    pub fn l1(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'l2' Input of this 'ResourceApplyProximalGradientDescent' operation.
    pub fn l2(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'delta' Input of this 'ResourceApplyProximalGradientDescent' operation.
    pub fn delta(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
}
impl From<ResourceApplyProximalGradientDescentInst> for crate::Operation {
    fn from(inst: ResourceApplyProximalGradientDescentInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ResourceApplyProximalGradientDescent::new().build(var, alpha, l1, l2, delta, scope)`.
pub fn resource_apply_proximal_gradient_descent<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
>(
    var: O0,
    alpha: O1,
    l1: O2,
    l2: O3,
    delta: O4,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ResourceApplyProximalGradientDescent::new().build(var, alpha, l1, l2, delta, scope)
}

/// Builder for the `ResourceApplyRMSProp` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ResourceApplyRMSProp {
    T: ::std::option::Option<crate::DataType>,
    use_locking: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ResourceApplyRMSProp' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ResourceApplyRMSPropInst {
    /// An instance of a fully built ResourceApplyRMSProp Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ResourceApplyRMSProp {
    /// Creates a new `ResourceApplyRMSProp`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_locking` attribute.
    pub fn use_locking<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.use_locking = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ResourceApplyRMSProp` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
        O6: ::std::convert::Into<crate::Output>,
        O7: ::std::convert::Into<crate::Output>,
    >(
        &self,
        var: O0,
        ms: O1,
        mom: O2,
        lr: O3,
        rho: O4,
        momentum: O5,
        epsilon: O6,
        grad: O7,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            var.into(),
            ms.into(),
            mom.into(),
            lr.into(),
            rho.into(),
            momentum.into(),
            epsilon.into(),
            grad.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        var: crate::Output,
        ms: crate::Output,
        mom: crate::Output,
        lr: crate::Output,
        rho: crate::Output,
        momentum: crate::Output,
        epsilon: crate::Output,
        grad: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ResourceApplyRMSProp", |nd| {
            nd.add_input(var);
            nd.add_input(ms);
            nd.add_input(mom);
            nd.add_input(lr);
            nd.add_input(rho);
            nd.add_input(momentum);
            nd.add_input(epsilon);
            nd.add_input(grad);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                nd.set_attr_bool("use_locking", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ResourceApplyRMSProp' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        var: crate::Output,
        ms: crate::Output,
        mom: crate::Output,
        lr: crate::Output,
        rho: crate::Output,
        momentum: crate::Output,
        epsilon: crate::Output,
        grad: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ResourceApplyRMSPropInst> {
        let op = scope.new_operation("ResourceApplyRMSProp", |builder| {
            builder.add_input(var);
            builder.add_input(ms);
            builder.add_input(mom);
            builder.add_input(lr);
            builder.add_input(rho);
            builder.add_input(momentum);
            builder.add_input(epsilon);
            builder.add_input(grad);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                builder.set_attr_bool("use_locking", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ResourceApplyRMSPropInst { op })
    }
}
impl ResourceApplyRMSPropInst {
    /// Returns the 'var' Input of this 'ResourceApplyRMSProp' operation.
    pub fn var(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'ms' Input of this 'ResourceApplyRMSProp' operation.
    pub fn ms(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'mom' Input of this 'ResourceApplyRMSProp' operation.
    pub fn mom(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'lr' Input of this 'ResourceApplyRMSProp' operation.
    pub fn lr(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'rho' Input of this 'ResourceApplyRMSProp' operation.
    pub fn rho(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
    /// Returns the 'momentum' Input of this 'ResourceApplyRMSProp' operation.
    pub fn momentum(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 5,
        }
    }
    /// Returns the 'epsilon' Input of this 'ResourceApplyRMSProp' operation.
    pub fn epsilon(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 6,
        }
    }
    /// Returns the 'grad' Input of this 'ResourceApplyRMSProp' operation.
    pub fn grad(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 7,
        }
    }
}
impl From<ResourceApplyRMSPropInst> for crate::Operation {
    fn from(inst: ResourceApplyRMSPropInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ResourceApplyRMSProp::new().build(var, ms, mom, lr, rho, momentum, epsilon, grad, scope)`.
pub fn resource_apply_rmsprop<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
    O6: ::std::convert::Into<crate::Output>,
    O7: ::std::convert::Into<crate::Output>,
>(
    var: O0,
    ms: O1,
    mom: O2,
    lr: O3,
    rho: O4,
    momentum: O5,
    epsilon: O6,
    grad: O7,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ResourceApplyRMSProp::new().build(var, ms, mom, lr, rho, momentum, epsilon, grad, scope)
}

/// Builder for the `ResourceConditionalAccumulator` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ResourceConditionalAccumulator {
    dtype: ::std::option::Option<crate::DataType>,
    shape: ::std::option::Option<crate::Shape>,
    container: ::std::option::Option<::std::string::String>,
    shared_name: ::std::option::Option<::std::string::String>,
    reduction_type: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ResourceConditionalAccumulator' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ResourceConditionalAccumulatorInst {
    /// An instance of a fully built ResourceConditionalAccumulator Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ResourceConditionalAccumulator {
    /// Creates a new `ResourceConditionalAccumulator`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `dtype` attribute.
    pub fn dtype<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shape` attribute.
    pub fn shape<ArgType: ::std::convert::Into<crate::Shape>>(mut self, value: ArgType) -> Self {
        self.shape = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `container` attribute.
    pub fn container<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.container = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shared_name` attribute.
    pub fn shared_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.shared_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `reduction_type` attribute.
    pub fn reduction_type<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.reduction_type = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ResourceConditionalAccumulator` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("ResourceConditionalAccumulator", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                nd.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shape {
                nd.set_attr_shape("shape", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.container {
                nd.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                nd.set_attr_string("shared_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.reduction_type {
                nd.set_attr_string("reduction_type", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ResourceConditionalAccumulator' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        scope: &mut crate::Scope,
    ) -> crate::Result<ResourceConditionalAccumulatorInst> {
        let op = scope.new_operation("ResourceConditionalAccumulator", |builder| {
            if let ::std::option::Option::Some(value) = &self.dtype {
                builder.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shape {
                builder.set_attr_shape("shape", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.container {
                builder.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                builder.set_attr_string("shared_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.reduction_type {
                builder.set_attr_string("reduction_type", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ResourceConditionalAccumulatorInst { op })
    }
}
impl ResourceConditionalAccumulatorInst {
    /// Returns the 'handle' Output of this 'ResourceConditionalAccumulator' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
}
impl From<ResourceConditionalAccumulatorInst> for crate::Operation {
    fn from(inst: ResourceConditionalAccumulatorInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ResourceConditionalAccumulator::new().build(scope)`.
pub fn resource_conditional_accumulator(
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ResourceConditionalAccumulator::new().build(scope)
}

/// Builder for the `ResourceCountUpTo` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ResourceCountUpTo {
    limit: ::std::option::Option<i64>,
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ResourceCountUpTo' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ResourceCountUpToInst {
    /// An instance of a fully built ResourceCountUpTo Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ResourceCountUpTo {
    /// Creates a new `ResourceCountUpTo`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `limit` attribute.
    pub fn limit<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.limit = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ResourceCountUpTo` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        resource: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(resource.into(), scope)
    }
    fn build_impl(
        &self,
        resource: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ResourceCountUpTo", |nd| {
            nd.add_input(resource);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.limit {
                nd.set_attr_int("limit", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ResourceCountUpTo' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        resource: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ResourceCountUpToInst> {
        let op = scope.new_operation("ResourceCountUpTo", |builder| {
            builder.add_input(resource);
            if let ::std::option::Option::Some(value) = &self.limit {
                builder.set_attr_int("limit", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ResourceCountUpToInst { op })
    }
}
impl ResourceCountUpToInst {
    /// Returns the 'output' Output of this 'ResourceCountUpTo' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'resource' Input of this 'ResourceCountUpTo' operation.
    pub fn resource(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<ResourceCountUpToInst> for crate::Operation {
    fn from(inst: ResourceCountUpToInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ResourceCountUpTo::new().build(resource, scope)`.
pub fn resource_count_up_to<O0: ::std::convert::Into<crate::Output>>(
    resource: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ResourceCountUpTo::new().build(resource, scope)
}

/// Builder for the `ResourceGather` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ResourceGather {
    batch_dims: ::std::option::Option<i64>,
    validate_indices: ::std::option::Option<bool>,
    dtype: ::std::option::Option<crate::DataType>,
    Tindices: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ResourceGather' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ResourceGatherInst {
    /// An instance of a fully built ResourceGather Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ResourceGather {
    /// Creates a new `ResourceGather`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `batch_dims` attribute.
    pub fn batch_dims<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.batch_dims = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `validate_indices` attribute.
    pub fn validate_indices<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.validate_indices = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `dtype` attribute.
    pub fn dtype<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tindices` attribute.
    pub fn Tindices<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tindices = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ResourceGather` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        resource: O0,
        indices: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(resource.into(), indices.into(), scope)
    }
    fn build_impl(
        &self,
        resource: crate::Output,
        indices: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ResourceGather", |nd| {
            nd.add_input(resource);
            nd.add_input(indices);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.batch_dims {
                nd.set_attr_int("batch_dims", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.validate_indices {
                nd.set_attr_bool("validate_indices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                nd.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                nd.set_attr_type("Tindices", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ResourceGather' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        resource: crate::Output,
        indices: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ResourceGatherInst> {
        let op = scope.new_operation("ResourceGather", |builder| {
            builder.add_input(resource);
            builder.add_input(indices);
            if let ::std::option::Option::Some(value) = &self.batch_dims {
                builder.set_attr_int("batch_dims", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.validate_indices {
                builder.set_attr_bool("validate_indices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                builder.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                builder.set_attr_type("Tindices", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ResourceGatherInst { op })
    }
}
impl ResourceGatherInst {
    /// Returns the 'output' Output of this 'ResourceGather' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'resource' Input of this 'ResourceGather' operation.
    pub fn resource(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'indices' Input of this 'ResourceGather' operation.
    pub fn indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<ResourceGatherInst> for crate::Operation {
    fn from(inst: ResourceGatherInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ResourceGather::new().build(resource, indices, scope)`.
pub fn resource_gather<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    resource: O0,
    indices: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ResourceGather::new().build(resource, indices, scope)
}

/// Builder for the `ResourceGatherNd` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ResourceGatherNd {
    dtype: ::std::option::Option<crate::DataType>,
    Tindices: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ResourceGatherNd' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ResourceGatherNdInst {
    /// An instance of a fully built ResourceGatherNd Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ResourceGatherNd {
    /// Creates a new `ResourceGatherNd`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `dtype` attribute.
    pub fn dtype<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tindices` attribute.
    pub fn Tindices<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tindices = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ResourceGatherNd` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        resource: O0,
        indices: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(resource.into(), indices.into(), scope)
    }
    fn build_impl(
        &self,
        resource: crate::Output,
        indices: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ResourceGatherNd", |nd| {
            nd.add_input(resource);
            nd.add_input(indices);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                nd.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                nd.set_attr_type("Tindices", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ResourceGatherNd' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        resource: crate::Output,
        indices: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ResourceGatherNdInst> {
        let op = scope.new_operation("ResourceGatherNd", |builder| {
            builder.add_input(resource);
            builder.add_input(indices);
            if let ::std::option::Option::Some(value) = &self.dtype {
                builder.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                builder.set_attr_type("Tindices", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ResourceGatherNdInst { op })
    }
}
impl ResourceGatherNdInst {
    /// Returns the 'output' Output of this 'ResourceGatherNd' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'resource' Input of this 'ResourceGatherNd' operation.
    pub fn resource(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'indices' Input of this 'ResourceGatherNd' operation.
    pub fn indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<ResourceGatherNdInst> for crate::Operation {
    fn from(inst: ResourceGatherNdInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ResourceGatherNd::new().build(resource, indices, scope)`.
pub fn resource_gather_nd<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    resource: O0,
    indices: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ResourceGatherNd::new().build(resource, indices, scope)
}

/// Builder for the `ResourceScatterAdd` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ResourceScatterAdd {
    dtype: ::std::option::Option<crate::DataType>,
    Tindices: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ResourceScatterAdd' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ResourceScatterAddInst {
    /// An instance of a fully built ResourceScatterAdd Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ResourceScatterAdd {
    /// Creates a new `ResourceScatterAdd`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `dtype` attribute.
    pub fn dtype<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tindices` attribute.
    pub fn Tindices<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tindices = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ResourceScatterAdd` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        resource: O0,
        indices: O1,
        updates: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(resource.into(), indices.into(), updates.into(), scope)
    }
    fn build_impl(
        &self,
        resource: crate::Output,
        indices: crate::Output,
        updates: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ResourceScatterAdd", |nd| {
            nd.add_input(resource);
            nd.add_input(indices);
            nd.add_input(updates);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                nd.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                nd.set_attr_type("Tindices", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ResourceScatterAdd' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        resource: crate::Output,
        indices: crate::Output,
        updates: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ResourceScatterAddInst> {
        let op = scope.new_operation("ResourceScatterAdd", |builder| {
            builder.add_input(resource);
            builder.add_input(indices);
            builder.add_input(updates);
            if let ::std::option::Option::Some(value) = &self.dtype {
                builder.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                builder.set_attr_type("Tindices", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ResourceScatterAddInst { op })
    }
}
impl ResourceScatterAddInst {
    /// Returns the 'resource' Input of this 'ResourceScatterAdd' operation.
    pub fn resource(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'indices' Input of this 'ResourceScatterAdd' operation.
    pub fn indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'updates' Input of this 'ResourceScatterAdd' operation.
    pub fn updates(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<ResourceScatterAddInst> for crate::Operation {
    fn from(inst: ResourceScatterAddInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ResourceScatterAdd::new().build(resource, indices, updates, scope)`.
pub fn resource_scatter_add<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    resource: O0,
    indices: O1,
    updates: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ResourceScatterAdd::new().build(resource, indices, updates, scope)
}

/// Builder for the `ResourceScatterDiv` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ResourceScatterDiv {
    dtype: ::std::option::Option<crate::DataType>,
    Tindices: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ResourceScatterDiv' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ResourceScatterDivInst {
    /// An instance of a fully built ResourceScatterDiv Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ResourceScatterDiv {
    /// Creates a new `ResourceScatterDiv`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `dtype` attribute.
    pub fn dtype<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tindices` attribute.
    pub fn Tindices<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tindices = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ResourceScatterDiv` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        resource: O0,
        indices: O1,
        updates: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(resource.into(), indices.into(), updates.into(), scope)
    }
    fn build_impl(
        &self,
        resource: crate::Output,
        indices: crate::Output,
        updates: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ResourceScatterDiv", |nd| {
            nd.add_input(resource);
            nd.add_input(indices);
            nd.add_input(updates);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                nd.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                nd.set_attr_type("Tindices", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ResourceScatterDiv' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        resource: crate::Output,
        indices: crate::Output,
        updates: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ResourceScatterDivInst> {
        let op = scope.new_operation("ResourceScatterDiv", |builder| {
            builder.add_input(resource);
            builder.add_input(indices);
            builder.add_input(updates);
            if let ::std::option::Option::Some(value) = &self.dtype {
                builder.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                builder.set_attr_type("Tindices", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ResourceScatterDivInst { op })
    }
}
impl ResourceScatterDivInst {
    /// Returns the 'resource' Input of this 'ResourceScatterDiv' operation.
    pub fn resource(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'indices' Input of this 'ResourceScatterDiv' operation.
    pub fn indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'updates' Input of this 'ResourceScatterDiv' operation.
    pub fn updates(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<ResourceScatterDivInst> for crate::Operation {
    fn from(inst: ResourceScatterDivInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ResourceScatterDiv::new().build(resource, indices, updates, scope)`.
pub fn resource_scatter_div<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    resource: O0,
    indices: O1,
    updates: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ResourceScatterDiv::new().build(resource, indices, updates, scope)
}

/// Builder for the `ResourceScatterMax` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ResourceScatterMax {
    dtype: ::std::option::Option<crate::DataType>,
    Tindices: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ResourceScatterMax' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ResourceScatterMaxInst {
    /// An instance of a fully built ResourceScatterMax Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ResourceScatterMax {
    /// Creates a new `ResourceScatterMax`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `dtype` attribute.
    pub fn dtype<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tindices` attribute.
    pub fn Tindices<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tindices = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ResourceScatterMax` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        resource: O0,
        indices: O1,
        updates: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(resource.into(), indices.into(), updates.into(), scope)
    }
    fn build_impl(
        &self,
        resource: crate::Output,
        indices: crate::Output,
        updates: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ResourceScatterMax", |nd| {
            nd.add_input(resource);
            nd.add_input(indices);
            nd.add_input(updates);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                nd.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                nd.set_attr_type("Tindices", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ResourceScatterMax' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        resource: crate::Output,
        indices: crate::Output,
        updates: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ResourceScatterMaxInst> {
        let op = scope.new_operation("ResourceScatterMax", |builder| {
            builder.add_input(resource);
            builder.add_input(indices);
            builder.add_input(updates);
            if let ::std::option::Option::Some(value) = &self.dtype {
                builder.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                builder.set_attr_type("Tindices", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ResourceScatterMaxInst { op })
    }
}
impl ResourceScatterMaxInst {
    /// Returns the 'resource' Input of this 'ResourceScatterMax' operation.
    pub fn resource(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'indices' Input of this 'ResourceScatterMax' operation.
    pub fn indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'updates' Input of this 'ResourceScatterMax' operation.
    pub fn updates(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<ResourceScatterMaxInst> for crate::Operation {
    fn from(inst: ResourceScatterMaxInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ResourceScatterMax::new().build(resource, indices, updates, scope)`.
pub fn resource_scatter_max<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    resource: O0,
    indices: O1,
    updates: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ResourceScatterMax::new().build(resource, indices, updates, scope)
}

/// Builder for the `ResourceScatterMin` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ResourceScatterMin {
    dtype: ::std::option::Option<crate::DataType>,
    Tindices: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ResourceScatterMin' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ResourceScatterMinInst {
    /// An instance of a fully built ResourceScatterMin Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ResourceScatterMin {
    /// Creates a new `ResourceScatterMin`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `dtype` attribute.
    pub fn dtype<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tindices` attribute.
    pub fn Tindices<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tindices = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ResourceScatterMin` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        resource: O0,
        indices: O1,
        updates: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(resource.into(), indices.into(), updates.into(), scope)
    }
    fn build_impl(
        &self,
        resource: crate::Output,
        indices: crate::Output,
        updates: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ResourceScatterMin", |nd| {
            nd.add_input(resource);
            nd.add_input(indices);
            nd.add_input(updates);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                nd.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                nd.set_attr_type("Tindices", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ResourceScatterMin' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        resource: crate::Output,
        indices: crate::Output,
        updates: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ResourceScatterMinInst> {
        let op = scope.new_operation("ResourceScatterMin", |builder| {
            builder.add_input(resource);
            builder.add_input(indices);
            builder.add_input(updates);
            if let ::std::option::Option::Some(value) = &self.dtype {
                builder.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                builder.set_attr_type("Tindices", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ResourceScatterMinInst { op })
    }
}
impl ResourceScatterMinInst {
    /// Returns the 'resource' Input of this 'ResourceScatterMin' operation.
    pub fn resource(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'indices' Input of this 'ResourceScatterMin' operation.
    pub fn indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'updates' Input of this 'ResourceScatterMin' operation.
    pub fn updates(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<ResourceScatterMinInst> for crate::Operation {
    fn from(inst: ResourceScatterMinInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ResourceScatterMin::new().build(resource, indices, updates, scope)`.
pub fn resource_scatter_min<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    resource: O0,
    indices: O1,
    updates: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ResourceScatterMin::new().build(resource, indices, updates, scope)
}

/// Builder for the `ResourceScatterMul` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ResourceScatterMul {
    dtype: ::std::option::Option<crate::DataType>,
    Tindices: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ResourceScatterMul' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ResourceScatterMulInst {
    /// An instance of a fully built ResourceScatterMul Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ResourceScatterMul {
    /// Creates a new `ResourceScatterMul`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `dtype` attribute.
    pub fn dtype<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tindices` attribute.
    pub fn Tindices<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tindices = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ResourceScatterMul` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        resource: O0,
        indices: O1,
        updates: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(resource.into(), indices.into(), updates.into(), scope)
    }
    fn build_impl(
        &self,
        resource: crate::Output,
        indices: crate::Output,
        updates: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ResourceScatterMul", |nd| {
            nd.add_input(resource);
            nd.add_input(indices);
            nd.add_input(updates);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                nd.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                nd.set_attr_type("Tindices", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ResourceScatterMul' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        resource: crate::Output,
        indices: crate::Output,
        updates: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ResourceScatterMulInst> {
        let op = scope.new_operation("ResourceScatterMul", |builder| {
            builder.add_input(resource);
            builder.add_input(indices);
            builder.add_input(updates);
            if let ::std::option::Option::Some(value) = &self.dtype {
                builder.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                builder.set_attr_type("Tindices", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ResourceScatterMulInst { op })
    }
}
impl ResourceScatterMulInst {
    /// Returns the 'resource' Input of this 'ResourceScatterMul' operation.
    pub fn resource(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'indices' Input of this 'ResourceScatterMul' operation.
    pub fn indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'updates' Input of this 'ResourceScatterMul' operation.
    pub fn updates(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<ResourceScatterMulInst> for crate::Operation {
    fn from(inst: ResourceScatterMulInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ResourceScatterMul::new().build(resource, indices, updates, scope)`.
pub fn resource_scatter_mul<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    resource: O0,
    indices: O1,
    updates: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ResourceScatterMul::new().build(resource, indices, updates, scope)
}

/// Builder for the `ResourceScatterNdAdd` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ResourceScatterNdAdd {
    T: ::std::option::Option<crate::DataType>,
    Tindices: ::std::option::Option<crate::DataType>,
    use_locking: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ResourceScatterNdAdd' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ResourceScatterNdAddInst {
    /// An instance of a fully built ResourceScatterNdAdd Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ResourceScatterNdAdd {
    /// Creates a new `ResourceScatterNdAdd`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tindices` attribute.
    pub fn Tindices<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tindices = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_locking` attribute.
    pub fn use_locking<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.use_locking = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ResourceScatterNdAdd` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        ref_: O0,
        indices: O1,
        updates: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(ref_.into(), indices.into(), updates.into(), scope)
    }
    fn build_impl(
        &self,
        ref_: crate::Output,
        indices: crate::Output,
        updates: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ResourceScatterNdAdd", |nd| {
            nd.add_input(ref_);
            nd.add_input(indices);
            nd.add_input(updates);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                nd.set_attr_type("Tindices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                nd.set_attr_bool("use_locking", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ResourceScatterNdAdd' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        ref_: crate::Output,
        indices: crate::Output,
        updates: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ResourceScatterNdAddInst> {
        let op = scope.new_operation("ResourceScatterNdAdd", |builder| {
            builder.add_input(ref_);
            builder.add_input(indices);
            builder.add_input(updates);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                builder.set_attr_type("Tindices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                builder.set_attr_bool("use_locking", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ResourceScatterNdAddInst { op })
    }
}
impl ResourceScatterNdAddInst {
    /// Returns the 'ref_' Input of this 'ResourceScatterNdAdd' operation.
    pub fn ref_(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'indices' Input of this 'ResourceScatterNdAdd' operation.
    pub fn indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'updates' Input of this 'ResourceScatterNdAdd' operation.
    pub fn updates(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<ResourceScatterNdAddInst> for crate::Operation {
    fn from(inst: ResourceScatterNdAddInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ResourceScatterNdAdd::new().build(ref_, indices, updates, scope)`.
pub fn resource_scatter_nd_add<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    ref_: O0,
    indices: O1,
    updates: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ResourceScatterNdAdd::new().build(ref_, indices, updates, scope)
}

/// Builder for the `ResourceScatterNdMax` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ResourceScatterNdMax {
    T: ::std::option::Option<crate::DataType>,
    Tindices: ::std::option::Option<crate::DataType>,
    use_locking: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ResourceScatterNdMax' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ResourceScatterNdMaxInst {
    /// An instance of a fully built ResourceScatterNdMax Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ResourceScatterNdMax {
    /// Creates a new `ResourceScatterNdMax`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tindices` attribute.
    pub fn Tindices<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tindices = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_locking` attribute.
    pub fn use_locking<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.use_locking = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ResourceScatterNdMax` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        ref_: O0,
        indices: O1,
        updates: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(ref_.into(), indices.into(), updates.into(), scope)
    }
    fn build_impl(
        &self,
        ref_: crate::Output,
        indices: crate::Output,
        updates: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ResourceScatterNdMax", |nd| {
            nd.add_input(ref_);
            nd.add_input(indices);
            nd.add_input(updates);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                nd.set_attr_type("Tindices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                nd.set_attr_bool("use_locking", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ResourceScatterNdMax' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        ref_: crate::Output,
        indices: crate::Output,
        updates: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ResourceScatterNdMaxInst> {
        let op = scope.new_operation("ResourceScatterNdMax", |builder| {
            builder.add_input(ref_);
            builder.add_input(indices);
            builder.add_input(updates);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                builder.set_attr_type("Tindices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                builder.set_attr_bool("use_locking", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ResourceScatterNdMaxInst { op })
    }
}
impl ResourceScatterNdMaxInst {
    /// Returns the 'ref_' Input of this 'ResourceScatterNdMax' operation.
    pub fn ref_(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'indices' Input of this 'ResourceScatterNdMax' operation.
    pub fn indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'updates' Input of this 'ResourceScatterNdMax' operation.
    pub fn updates(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<ResourceScatterNdMaxInst> for crate::Operation {
    fn from(inst: ResourceScatterNdMaxInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ResourceScatterNdMax::new().build(ref_, indices, updates, scope)`.
pub fn resource_scatter_nd_max<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    ref_: O0,
    indices: O1,
    updates: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ResourceScatterNdMax::new().build(ref_, indices, updates, scope)
}

/// Builder for the `ResourceScatterNdMin` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ResourceScatterNdMin {
    T: ::std::option::Option<crate::DataType>,
    Tindices: ::std::option::Option<crate::DataType>,
    use_locking: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ResourceScatterNdMin' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ResourceScatterNdMinInst {
    /// An instance of a fully built ResourceScatterNdMin Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ResourceScatterNdMin {
    /// Creates a new `ResourceScatterNdMin`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tindices` attribute.
    pub fn Tindices<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tindices = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_locking` attribute.
    pub fn use_locking<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.use_locking = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ResourceScatterNdMin` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        ref_: O0,
        indices: O1,
        updates: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(ref_.into(), indices.into(), updates.into(), scope)
    }
    fn build_impl(
        &self,
        ref_: crate::Output,
        indices: crate::Output,
        updates: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ResourceScatterNdMin", |nd| {
            nd.add_input(ref_);
            nd.add_input(indices);
            nd.add_input(updates);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                nd.set_attr_type("Tindices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                nd.set_attr_bool("use_locking", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ResourceScatterNdMin' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        ref_: crate::Output,
        indices: crate::Output,
        updates: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ResourceScatterNdMinInst> {
        let op = scope.new_operation("ResourceScatterNdMin", |builder| {
            builder.add_input(ref_);
            builder.add_input(indices);
            builder.add_input(updates);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                builder.set_attr_type("Tindices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                builder.set_attr_bool("use_locking", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ResourceScatterNdMinInst { op })
    }
}
impl ResourceScatterNdMinInst {
    /// Returns the 'ref_' Input of this 'ResourceScatterNdMin' operation.
    pub fn ref_(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'indices' Input of this 'ResourceScatterNdMin' operation.
    pub fn indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'updates' Input of this 'ResourceScatterNdMin' operation.
    pub fn updates(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<ResourceScatterNdMinInst> for crate::Operation {
    fn from(inst: ResourceScatterNdMinInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ResourceScatterNdMin::new().build(ref_, indices, updates, scope)`.
pub fn resource_scatter_nd_min<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    ref_: O0,
    indices: O1,
    updates: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ResourceScatterNdMin::new().build(ref_, indices, updates, scope)
}

/// Builder for the `ResourceScatterNdSub` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ResourceScatterNdSub {
    T: ::std::option::Option<crate::DataType>,
    Tindices: ::std::option::Option<crate::DataType>,
    use_locking: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ResourceScatterNdSub' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ResourceScatterNdSubInst {
    /// An instance of a fully built ResourceScatterNdSub Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ResourceScatterNdSub {
    /// Creates a new `ResourceScatterNdSub`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tindices` attribute.
    pub fn Tindices<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tindices = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_locking` attribute.
    pub fn use_locking<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.use_locking = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ResourceScatterNdSub` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        ref_: O0,
        indices: O1,
        updates: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(ref_.into(), indices.into(), updates.into(), scope)
    }
    fn build_impl(
        &self,
        ref_: crate::Output,
        indices: crate::Output,
        updates: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ResourceScatterNdSub", |nd| {
            nd.add_input(ref_);
            nd.add_input(indices);
            nd.add_input(updates);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                nd.set_attr_type("Tindices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                nd.set_attr_bool("use_locking", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ResourceScatterNdSub' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        ref_: crate::Output,
        indices: crate::Output,
        updates: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ResourceScatterNdSubInst> {
        let op = scope.new_operation("ResourceScatterNdSub", |builder| {
            builder.add_input(ref_);
            builder.add_input(indices);
            builder.add_input(updates);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                builder.set_attr_type("Tindices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                builder.set_attr_bool("use_locking", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ResourceScatterNdSubInst { op })
    }
}
impl ResourceScatterNdSubInst {
    /// Returns the 'ref_' Input of this 'ResourceScatterNdSub' operation.
    pub fn ref_(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'indices' Input of this 'ResourceScatterNdSub' operation.
    pub fn indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'updates' Input of this 'ResourceScatterNdSub' operation.
    pub fn updates(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<ResourceScatterNdSubInst> for crate::Operation {
    fn from(inst: ResourceScatterNdSubInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ResourceScatterNdSub::new().build(ref_, indices, updates, scope)`.
pub fn resource_scatter_nd_sub<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    ref_: O0,
    indices: O1,
    updates: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ResourceScatterNdSub::new().build(ref_, indices, updates, scope)
}

/// Builder for the `ResourceScatterNdUpdate` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ResourceScatterNdUpdate {
    T: ::std::option::Option<crate::DataType>,
    Tindices: ::std::option::Option<crate::DataType>,
    use_locking: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ResourceScatterNdUpdate' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ResourceScatterNdUpdateInst {
    /// An instance of a fully built ResourceScatterNdUpdate Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ResourceScatterNdUpdate {
    /// Creates a new `ResourceScatterNdUpdate`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tindices` attribute.
    pub fn Tindices<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tindices = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_locking` attribute.
    pub fn use_locking<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.use_locking = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ResourceScatterNdUpdate` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        ref_: O0,
        indices: O1,
        updates: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(ref_.into(), indices.into(), updates.into(), scope)
    }
    fn build_impl(
        &self,
        ref_: crate::Output,
        indices: crate::Output,
        updates: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ResourceScatterNdUpdate", |nd| {
            nd.add_input(ref_);
            nd.add_input(indices);
            nd.add_input(updates);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                nd.set_attr_type("Tindices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                nd.set_attr_bool("use_locking", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ResourceScatterNdUpdate' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        ref_: crate::Output,
        indices: crate::Output,
        updates: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ResourceScatterNdUpdateInst> {
        let op = scope.new_operation("ResourceScatterNdUpdate", |builder| {
            builder.add_input(ref_);
            builder.add_input(indices);
            builder.add_input(updates);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                builder.set_attr_type("Tindices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                builder.set_attr_bool("use_locking", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ResourceScatterNdUpdateInst { op })
    }
}
impl ResourceScatterNdUpdateInst {
    /// Returns the 'ref_' Input of this 'ResourceScatterNdUpdate' operation.
    pub fn ref_(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'indices' Input of this 'ResourceScatterNdUpdate' operation.
    pub fn indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'updates' Input of this 'ResourceScatterNdUpdate' operation.
    pub fn updates(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<ResourceScatterNdUpdateInst> for crate::Operation {
    fn from(inst: ResourceScatterNdUpdateInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ResourceScatterNdUpdate::new().build(ref_, indices, updates, scope)`.
pub fn resource_scatter_nd_update<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    ref_: O0,
    indices: O1,
    updates: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ResourceScatterNdUpdate::new().build(ref_, indices, updates, scope)
}

/// Builder for the `ResourceScatterSub` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ResourceScatterSub {
    dtype: ::std::option::Option<crate::DataType>,
    Tindices: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ResourceScatterSub' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ResourceScatterSubInst {
    /// An instance of a fully built ResourceScatterSub Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ResourceScatterSub {
    /// Creates a new `ResourceScatterSub`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `dtype` attribute.
    pub fn dtype<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tindices` attribute.
    pub fn Tindices<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tindices = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ResourceScatterSub` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        resource: O0,
        indices: O1,
        updates: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(resource.into(), indices.into(), updates.into(), scope)
    }
    fn build_impl(
        &self,
        resource: crate::Output,
        indices: crate::Output,
        updates: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ResourceScatterSub", |nd| {
            nd.add_input(resource);
            nd.add_input(indices);
            nd.add_input(updates);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                nd.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                nd.set_attr_type("Tindices", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ResourceScatterSub' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        resource: crate::Output,
        indices: crate::Output,
        updates: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ResourceScatterSubInst> {
        let op = scope.new_operation("ResourceScatterSub", |builder| {
            builder.add_input(resource);
            builder.add_input(indices);
            builder.add_input(updates);
            if let ::std::option::Option::Some(value) = &self.dtype {
                builder.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                builder.set_attr_type("Tindices", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ResourceScatterSubInst { op })
    }
}
impl ResourceScatterSubInst {
    /// Returns the 'resource' Input of this 'ResourceScatterSub' operation.
    pub fn resource(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'indices' Input of this 'ResourceScatterSub' operation.
    pub fn indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'updates' Input of this 'ResourceScatterSub' operation.
    pub fn updates(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<ResourceScatterSubInst> for crate::Operation {
    fn from(inst: ResourceScatterSubInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ResourceScatterSub::new().build(resource, indices, updates, scope)`.
pub fn resource_scatter_sub<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    resource: O0,
    indices: O1,
    updates: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ResourceScatterSub::new().build(resource, indices, updates, scope)
}

/// Builder for the `ResourceScatterUpdate` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ResourceScatterUpdate {
    dtype: ::std::option::Option<crate::DataType>,
    Tindices: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ResourceScatterUpdate' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ResourceScatterUpdateInst {
    /// An instance of a fully built ResourceScatterUpdate Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ResourceScatterUpdate {
    /// Creates a new `ResourceScatterUpdate`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `dtype` attribute.
    pub fn dtype<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tindices` attribute.
    pub fn Tindices<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tindices = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ResourceScatterUpdate` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        resource: O0,
        indices: O1,
        updates: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(resource.into(), indices.into(), updates.into(), scope)
    }
    fn build_impl(
        &self,
        resource: crate::Output,
        indices: crate::Output,
        updates: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ResourceScatterUpdate", |nd| {
            nd.add_input(resource);
            nd.add_input(indices);
            nd.add_input(updates);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                nd.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                nd.set_attr_type("Tindices", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ResourceScatterUpdate' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        resource: crate::Output,
        indices: crate::Output,
        updates: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ResourceScatterUpdateInst> {
        let op = scope.new_operation("ResourceScatterUpdate", |builder| {
            builder.add_input(resource);
            builder.add_input(indices);
            builder.add_input(updates);
            if let ::std::option::Option::Some(value) = &self.dtype {
                builder.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                builder.set_attr_type("Tindices", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ResourceScatterUpdateInst { op })
    }
}
impl ResourceScatterUpdateInst {
    /// Returns the 'resource' Input of this 'ResourceScatterUpdate' operation.
    pub fn resource(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'indices' Input of this 'ResourceScatterUpdate' operation.
    pub fn indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'updates' Input of this 'ResourceScatterUpdate' operation.
    pub fn updates(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<ResourceScatterUpdateInst> for crate::Operation {
    fn from(inst: ResourceScatterUpdateInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ResourceScatterUpdate::new().build(resource, indices, updates, scope)`.
pub fn resource_scatter_update<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    resource: O0,
    indices: O1,
    updates: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ResourceScatterUpdate::new().build(resource, indices, updates, scope)
}

/// Builder for the `ResourceSparseApplyAdadelta` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ResourceSparseApplyAdadelta {
    T: ::std::option::Option<crate::DataType>,
    Tindices: ::std::option::Option<crate::DataType>,
    use_locking: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ResourceSparseApplyAdadelta' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ResourceSparseApplyAdadeltaInst {
    /// An instance of a fully built ResourceSparseApplyAdadelta Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ResourceSparseApplyAdadelta {
    /// Creates a new `ResourceSparseApplyAdadelta`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tindices` attribute.
    pub fn Tindices<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tindices = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_locking` attribute.
    pub fn use_locking<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.use_locking = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ResourceSparseApplyAdadelta` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
        O6: ::std::convert::Into<crate::Output>,
        O7: ::std::convert::Into<crate::Output>,
    >(
        &self,
        var: O0,
        accum: O1,
        accum_update: O2,
        lr: O3,
        rho: O4,
        epsilon: O5,
        grad: O6,
        indices: O7,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            var.into(),
            accum.into(),
            accum_update.into(),
            lr.into(),
            rho.into(),
            epsilon.into(),
            grad.into(),
            indices.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        var: crate::Output,
        accum: crate::Output,
        accum_update: crate::Output,
        lr: crate::Output,
        rho: crate::Output,
        epsilon: crate::Output,
        grad: crate::Output,
        indices: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ResourceSparseApplyAdadelta", |nd| {
            nd.add_input(var);
            nd.add_input(accum);
            nd.add_input(accum_update);
            nd.add_input(lr);
            nd.add_input(rho);
            nd.add_input(epsilon);
            nd.add_input(grad);
            nd.add_input(indices);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                nd.set_attr_type("Tindices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                nd.set_attr_bool("use_locking", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ResourceSparseApplyAdadelta' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        var: crate::Output,
        accum: crate::Output,
        accum_update: crate::Output,
        lr: crate::Output,
        rho: crate::Output,
        epsilon: crate::Output,
        grad: crate::Output,
        indices: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ResourceSparseApplyAdadeltaInst> {
        let op = scope.new_operation("ResourceSparseApplyAdadelta", |builder| {
            builder.add_input(var);
            builder.add_input(accum);
            builder.add_input(accum_update);
            builder.add_input(lr);
            builder.add_input(rho);
            builder.add_input(epsilon);
            builder.add_input(grad);
            builder.add_input(indices);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                builder.set_attr_type("Tindices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                builder.set_attr_bool("use_locking", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ResourceSparseApplyAdadeltaInst { op })
    }
}
impl ResourceSparseApplyAdadeltaInst {
    /// Returns the 'var' Input of this 'ResourceSparseApplyAdadelta' operation.
    pub fn var(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'accum' Input of this 'ResourceSparseApplyAdadelta' operation.
    pub fn accum(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'accum_update' Input of this 'ResourceSparseApplyAdadelta' operation.
    pub fn accum_update(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'lr' Input of this 'ResourceSparseApplyAdadelta' operation.
    pub fn lr(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'rho' Input of this 'ResourceSparseApplyAdadelta' operation.
    pub fn rho(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
    /// Returns the 'epsilon' Input of this 'ResourceSparseApplyAdadelta' operation.
    pub fn epsilon(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 5,
        }
    }
    /// Returns the 'grad' Input of this 'ResourceSparseApplyAdadelta' operation.
    pub fn grad(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 6,
        }
    }
    /// Returns the 'indices' Input of this 'ResourceSparseApplyAdadelta' operation.
    pub fn indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 7,
        }
    }
}
impl From<ResourceSparseApplyAdadeltaInst> for crate::Operation {
    fn from(inst: ResourceSparseApplyAdadeltaInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ResourceSparseApplyAdadelta::new().build(var, accum, accum_update, lr, rho, epsilon, grad, indices, scope)`.
pub fn resource_sparse_apply_adadelta<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
    O6: ::std::convert::Into<crate::Output>,
    O7: ::std::convert::Into<crate::Output>,
>(
    var: O0,
    accum: O1,
    accum_update: O2,
    lr: O3,
    rho: O4,
    epsilon: O5,
    grad: O6,
    indices: O7,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ResourceSparseApplyAdadelta::new().build(
        var,
        accum,
        accum_update,
        lr,
        rho,
        epsilon,
        grad,
        indices,
        scope,
    )
}

/// Builder for the `ResourceSparseApplyAdagrad` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ResourceSparseApplyAdagrad {
    T: ::std::option::Option<crate::DataType>,
    Tindices: ::std::option::Option<crate::DataType>,
    use_locking: ::std::option::Option<bool>,
    update_slots: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ResourceSparseApplyAdagrad' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ResourceSparseApplyAdagradInst {
    /// An instance of a fully built ResourceSparseApplyAdagrad Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ResourceSparseApplyAdagrad {
    /// Creates a new `ResourceSparseApplyAdagrad`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tindices` attribute.
    pub fn Tindices<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tindices = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_locking` attribute.
    pub fn use_locking<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.use_locking = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `update_slots` attribute.
    pub fn update_slots<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.update_slots = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ResourceSparseApplyAdagrad` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
    >(
        &self,
        var: O0,
        accum: O1,
        lr: O2,
        grad: O3,
        indices: O4,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            var.into(),
            accum.into(),
            lr.into(),
            grad.into(),
            indices.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        var: crate::Output,
        accum: crate::Output,
        lr: crate::Output,
        grad: crate::Output,
        indices: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ResourceSparseApplyAdagrad", |nd| {
            nd.add_input(var);
            nd.add_input(accum);
            nd.add_input(lr);
            nd.add_input(grad);
            nd.add_input(indices);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                nd.set_attr_type("Tindices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                nd.set_attr_bool("use_locking", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.update_slots {
                nd.set_attr_bool("update_slots", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ResourceSparseApplyAdagrad' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        var: crate::Output,
        accum: crate::Output,
        lr: crate::Output,
        grad: crate::Output,
        indices: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ResourceSparseApplyAdagradInst> {
        let op = scope.new_operation("ResourceSparseApplyAdagrad", |builder| {
            builder.add_input(var);
            builder.add_input(accum);
            builder.add_input(lr);
            builder.add_input(grad);
            builder.add_input(indices);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                builder.set_attr_type("Tindices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                builder.set_attr_bool("use_locking", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.update_slots {
                builder.set_attr_bool("update_slots", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ResourceSparseApplyAdagradInst { op })
    }
}
impl ResourceSparseApplyAdagradInst {
    /// Returns the 'var' Input of this 'ResourceSparseApplyAdagrad' operation.
    pub fn var(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'accum' Input of this 'ResourceSparseApplyAdagrad' operation.
    pub fn accum(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'lr' Input of this 'ResourceSparseApplyAdagrad' operation.
    pub fn lr(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'grad' Input of this 'ResourceSparseApplyAdagrad' operation.
    pub fn grad(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'indices' Input of this 'ResourceSparseApplyAdagrad' operation.
    pub fn indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
}
impl From<ResourceSparseApplyAdagradInst> for crate::Operation {
    fn from(inst: ResourceSparseApplyAdagradInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ResourceSparseApplyAdagrad::new().build(var, accum, lr, grad, indices, scope)`.
pub fn resource_sparse_apply_adagrad<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
>(
    var: O0,
    accum: O1,
    lr: O2,
    grad: O3,
    indices: O4,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ResourceSparseApplyAdagrad::new().build(var, accum, lr, grad, indices, scope)
}

/// Builder for the `ResourceSparseApplyAdagradDA` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ResourceSparseApplyAdagradDA {
    T: ::std::option::Option<crate::DataType>,
    Tindices: ::std::option::Option<crate::DataType>,
    use_locking: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ResourceSparseApplyAdagradDA' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ResourceSparseApplyAdagradDAInst {
    /// An instance of a fully built ResourceSparseApplyAdagradDA Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ResourceSparseApplyAdagradDA {
    /// Creates a new `ResourceSparseApplyAdagradDA`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tindices` attribute.
    pub fn Tindices<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tindices = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_locking` attribute.
    pub fn use_locking<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.use_locking = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ResourceSparseApplyAdagradDA` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
        O6: ::std::convert::Into<crate::Output>,
        O7: ::std::convert::Into<crate::Output>,
        O8: ::std::convert::Into<crate::Output>,
    >(
        &self,
        var: O0,
        gradient_accumulator: O1,
        gradient_squared_accumulator: O2,
        grad: O3,
        indices: O4,
        lr: O5,
        l1: O6,
        l2: O7,
        global_step: O8,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            var.into(),
            gradient_accumulator.into(),
            gradient_squared_accumulator.into(),
            grad.into(),
            indices.into(),
            lr.into(),
            l1.into(),
            l2.into(),
            global_step.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        var: crate::Output,
        gradient_accumulator: crate::Output,
        gradient_squared_accumulator: crate::Output,
        grad: crate::Output,
        indices: crate::Output,
        lr: crate::Output,
        l1: crate::Output,
        l2: crate::Output,
        global_step: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ResourceSparseApplyAdagradDA", |nd| {
            nd.add_input(var);
            nd.add_input(gradient_accumulator);
            nd.add_input(gradient_squared_accumulator);
            nd.add_input(grad);
            nd.add_input(indices);
            nd.add_input(lr);
            nd.add_input(l1);
            nd.add_input(l2);
            nd.add_input(global_step);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                nd.set_attr_type("Tindices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                nd.set_attr_bool("use_locking", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ResourceSparseApplyAdagradDA' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        var: crate::Output,
        gradient_accumulator: crate::Output,
        gradient_squared_accumulator: crate::Output,
        grad: crate::Output,
        indices: crate::Output,
        lr: crate::Output,
        l1: crate::Output,
        l2: crate::Output,
        global_step: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ResourceSparseApplyAdagradDAInst> {
        let op = scope.new_operation("ResourceSparseApplyAdagradDA", |builder| {
            builder.add_input(var);
            builder.add_input(gradient_accumulator);
            builder.add_input(gradient_squared_accumulator);
            builder.add_input(grad);
            builder.add_input(indices);
            builder.add_input(lr);
            builder.add_input(l1);
            builder.add_input(l2);
            builder.add_input(global_step);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                builder.set_attr_type("Tindices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                builder.set_attr_bool("use_locking", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ResourceSparseApplyAdagradDAInst { op })
    }
}
impl ResourceSparseApplyAdagradDAInst {
    /// Returns the 'var' Input of this 'ResourceSparseApplyAdagradDA' operation.
    pub fn var(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'gradient_accumulator' Input of this 'ResourceSparseApplyAdagradDA' operation.
    pub fn gradient_accumulator(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'gradient_squared_accumulator' Input of this 'ResourceSparseApplyAdagradDA' operation.
    pub fn gradient_squared_accumulator(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'grad' Input of this 'ResourceSparseApplyAdagradDA' operation.
    pub fn grad(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'indices' Input of this 'ResourceSparseApplyAdagradDA' operation.
    pub fn indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
    /// Returns the 'lr' Input of this 'ResourceSparseApplyAdagradDA' operation.
    pub fn lr(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 5,
        }
    }
    /// Returns the 'l1' Input of this 'ResourceSparseApplyAdagradDA' operation.
    pub fn l1(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 6,
        }
    }
    /// Returns the 'l2' Input of this 'ResourceSparseApplyAdagradDA' operation.
    pub fn l2(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 7,
        }
    }
    /// Returns the 'global_step' Input of this 'ResourceSparseApplyAdagradDA' operation.
    pub fn global_step(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 8,
        }
    }
}
impl From<ResourceSparseApplyAdagradDAInst> for crate::Operation {
    fn from(inst: ResourceSparseApplyAdagradDAInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ResourceSparseApplyAdagradDA::new().build(var, gradient_accumulator, gradient_squared_accumulator, grad, indices, lr, l1, l2, global_step, scope)`.
pub fn resource_sparse_apply_adagrad_da<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
    O6: ::std::convert::Into<crate::Output>,
    O7: ::std::convert::Into<crate::Output>,
    O8: ::std::convert::Into<crate::Output>,
>(
    var: O0,
    gradient_accumulator: O1,
    gradient_squared_accumulator: O2,
    grad: O3,
    indices: O4,
    lr: O5,
    l1: O6,
    l2: O7,
    global_step: O8,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ResourceSparseApplyAdagradDA::new().build(
        var,
        gradient_accumulator,
        gradient_squared_accumulator,
        grad,
        indices,
        lr,
        l1,
        l2,
        global_step,
        scope,
    )
}

/// Builder for the `ResourceSparseApplyAdagradV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ResourceSparseApplyAdagradV2 {
    T: ::std::option::Option<crate::DataType>,
    Tindices: ::std::option::Option<crate::DataType>,
    use_locking: ::std::option::Option<bool>,
    update_slots: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ResourceSparseApplyAdagradV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ResourceSparseApplyAdagradV2Inst {
    /// An instance of a fully built ResourceSparseApplyAdagradV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ResourceSparseApplyAdagradV2 {
    /// Creates a new `ResourceSparseApplyAdagradV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tindices` attribute.
    pub fn Tindices<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tindices = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_locking` attribute.
    pub fn use_locking<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.use_locking = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `update_slots` attribute.
    pub fn update_slots<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.update_slots = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ResourceSparseApplyAdagradV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
    >(
        &self,
        var: O0,
        accum: O1,
        lr: O2,
        epsilon: O3,
        grad: O4,
        indices: O5,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            var.into(),
            accum.into(),
            lr.into(),
            epsilon.into(),
            grad.into(),
            indices.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        var: crate::Output,
        accum: crate::Output,
        lr: crate::Output,
        epsilon: crate::Output,
        grad: crate::Output,
        indices: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ResourceSparseApplyAdagradV2", |nd| {
            nd.add_input(var);
            nd.add_input(accum);
            nd.add_input(lr);
            nd.add_input(epsilon);
            nd.add_input(grad);
            nd.add_input(indices);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                nd.set_attr_type("Tindices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                nd.set_attr_bool("use_locking", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.update_slots {
                nd.set_attr_bool("update_slots", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ResourceSparseApplyAdagradV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        var: crate::Output,
        accum: crate::Output,
        lr: crate::Output,
        epsilon: crate::Output,
        grad: crate::Output,
        indices: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ResourceSparseApplyAdagradV2Inst> {
        let op = scope.new_operation("ResourceSparseApplyAdagradV2", |builder| {
            builder.add_input(var);
            builder.add_input(accum);
            builder.add_input(lr);
            builder.add_input(epsilon);
            builder.add_input(grad);
            builder.add_input(indices);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                builder.set_attr_type("Tindices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                builder.set_attr_bool("use_locking", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.update_slots {
                builder.set_attr_bool("update_slots", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ResourceSparseApplyAdagradV2Inst { op })
    }
}
impl ResourceSparseApplyAdagradV2Inst {
    /// Returns the 'var' Input of this 'ResourceSparseApplyAdagradV2' operation.
    pub fn var(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'accum' Input of this 'ResourceSparseApplyAdagradV2' operation.
    pub fn accum(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'lr' Input of this 'ResourceSparseApplyAdagradV2' operation.
    pub fn lr(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'epsilon' Input of this 'ResourceSparseApplyAdagradV2' operation.
    pub fn epsilon(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'grad' Input of this 'ResourceSparseApplyAdagradV2' operation.
    pub fn grad(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
    /// Returns the 'indices' Input of this 'ResourceSparseApplyAdagradV2' operation.
    pub fn indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 5,
        }
    }
}
impl From<ResourceSparseApplyAdagradV2Inst> for crate::Operation {
    fn from(inst: ResourceSparseApplyAdagradV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ResourceSparseApplyAdagradV2::new().build(var, accum, lr, epsilon, grad, indices, scope)`.
pub fn resource_sparse_apply_adagrad_v2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
>(
    var: O0,
    accum: O1,
    lr: O2,
    epsilon: O3,
    grad: O4,
    indices: O5,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ResourceSparseApplyAdagradV2::new().build(var, accum, lr, epsilon, grad, indices, scope)
}

/// Builder for the `ResourceSparseApplyCenteredRMSProp` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ResourceSparseApplyCenteredRMSProp {
    T: ::std::option::Option<crate::DataType>,
    Tindices: ::std::option::Option<crate::DataType>,
    use_locking: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ResourceSparseApplyCenteredRMSProp' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ResourceSparseApplyCenteredRMSPropInst {
    /// An instance of a fully built ResourceSparseApplyCenteredRMSProp Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ResourceSparseApplyCenteredRMSProp {
    /// Creates a new `ResourceSparseApplyCenteredRMSProp`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tindices` attribute.
    pub fn Tindices<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tindices = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_locking` attribute.
    pub fn use_locking<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.use_locking = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ResourceSparseApplyCenteredRMSProp` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
        O6: ::std::convert::Into<crate::Output>,
        O7: ::std::convert::Into<crate::Output>,
        O8: ::std::convert::Into<crate::Output>,
        O9: ::std::convert::Into<crate::Output>,
    >(
        &self,
        var: O0,
        mg: O1,
        ms: O2,
        mom: O3,
        lr: O4,
        rho: O5,
        momentum: O6,
        epsilon: O7,
        grad: O8,
        indices: O9,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            var.into(),
            mg.into(),
            ms.into(),
            mom.into(),
            lr.into(),
            rho.into(),
            momentum.into(),
            epsilon.into(),
            grad.into(),
            indices.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        var: crate::Output,
        mg: crate::Output,
        ms: crate::Output,
        mom: crate::Output,
        lr: crate::Output,
        rho: crate::Output,
        momentum: crate::Output,
        epsilon: crate::Output,
        grad: crate::Output,
        indices: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ResourceSparseApplyCenteredRMSProp", |nd| {
            nd.add_input(var);
            nd.add_input(mg);
            nd.add_input(ms);
            nd.add_input(mom);
            nd.add_input(lr);
            nd.add_input(rho);
            nd.add_input(momentum);
            nd.add_input(epsilon);
            nd.add_input(grad);
            nd.add_input(indices);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                nd.set_attr_type("Tindices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                nd.set_attr_bool("use_locking", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ResourceSparseApplyCenteredRMSProp' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        var: crate::Output,
        mg: crate::Output,
        ms: crate::Output,
        mom: crate::Output,
        lr: crate::Output,
        rho: crate::Output,
        momentum: crate::Output,
        epsilon: crate::Output,
        grad: crate::Output,
        indices: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ResourceSparseApplyCenteredRMSPropInst> {
        let op = scope.new_operation("ResourceSparseApplyCenteredRMSProp", |builder| {
            builder.add_input(var);
            builder.add_input(mg);
            builder.add_input(ms);
            builder.add_input(mom);
            builder.add_input(lr);
            builder.add_input(rho);
            builder.add_input(momentum);
            builder.add_input(epsilon);
            builder.add_input(grad);
            builder.add_input(indices);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                builder.set_attr_type("Tindices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                builder.set_attr_bool("use_locking", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ResourceSparseApplyCenteredRMSPropInst { op })
    }
}
impl ResourceSparseApplyCenteredRMSPropInst {
    /// Returns the 'var' Input of this 'ResourceSparseApplyCenteredRMSProp' operation.
    pub fn var(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'mg' Input of this 'ResourceSparseApplyCenteredRMSProp' operation.
    pub fn mg(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'ms' Input of this 'ResourceSparseApplyCenteredRMSProp' operation.
    pub fn ms(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'mom' Input of this 'ResourceSparseApplyCenteredRMSProp' operation.
    pub fn mom(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'lr' Input of this 'ResourceSparseApplyCenteredRMSProp' operation.
    pub fn lr(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
    /// Returns the 'rho' Input of this 'ResourceSparseApplyCenteredRMSProp' operation.
    pub fn rho(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 5,
        }
    }
    /// Returns the 'momentum' Input of this 'ResourceSparseApplyCenteredRMSProp' operation.
    pub fn momentum(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 6,
        }
    }
    /// Returns the 'epsilon' Input of this 'ResourceSparseApplyCenteredRMSProp' operation.
    pub fn epsilon(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 7,
        }
    }
    /// Returns the 'grad' Input of this 'ResourceSparseApplyCenteredRMSProp' operation.
    pub fn grad(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 8,
        }
    }
    /// Returns the 'indices' Input of this 'ResourceSparseApplyCenteredRMSProp' operation.
    pub fn indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 9,
        }
    }
}
impl From<ResourceSparseApplyCenteredRMSPropInst> for crate::Operation {
    fn from(inst: ResourceSparseApplyCenteredRMSPropInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ResourceSparseApplyCenteredRMSProp::new().build(var, mg, ms, mom, lr, rho, momentum, epsilon, grad, indices, scope)`.
pub fn resource_sparse_apply_centered_rmsprop<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
    O6: ::std::convert::Into<crate::Output>,
    O7: ::std::convert::Into<crate::Output>,
    O8: ::std::convert::Into<crate::Output>,
    O9: ::std::convert::Into<crate::Output>,
>(
    var: O0,
    mg: O1,
    ms: O2,
    mom: O3,
    lr: O4,
    rho: O5,
    momentum: O6,
    epsilon: O7,
    grad: O8,
    indices: O9,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ResourceSparseApplyCenteredRMSProp::new().build(
        var, mg, ms, mom, lr, rho, momentum, epsilon, grad, indices, scope,
    )
}

/// Builder for the `ResourceSparseApplyFtrl` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ResourceSparseApplyFtrl {
    T: ::std::option::Option<crate::DataType>,
    Tindices: ::std::option::Option<crate::DataType>,
    use_locking: ::std::option::Option<bool>,
    multiply_linear_by_lr: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ResourceSparseApplyFtrl' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ResourceSparseApplyFtrlInst {
    /// An instance of a fully built ResourceSparseApplyFtrl Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ResourceSparseApplyFtrl {
    /// Creates a new `ResourceSparseApplyFtrl`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tindices` attribute.
    pub fn Tindices<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tindices = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_locking` attribute.
    pub fn use_locking<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.use_locking = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `multiply_linear_by_lr` attribute.
    pub fn multiply_linear_by_lr<ArgType: ::std::convert::Into<bool>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.multiply_linear_by_lr = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ResourceSparseApplyFtrl` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
        O6: ::std::convert::Into<crate::Output>,
        O7: ::std::convert::Into<crate::Output>,
        O8: ::std::convert::Into<crate::Output>,
    >(
        &self,
        var: O0,
        accum: O1,
        linear: O2,
        grad: O3,
        indices: O4,
        lr: O5,
        l1: O6,
        l2: O7,
        lr_power: O8,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            var.into(),
            accum.into(),
            linear.into(),
            grad.into(),
            indices.into(),
            lr.into(),
            l1.into(),
            l2.into(),
            lr_power.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        var: crate::Output,
        accum: crate::Output,
        linear: crate::Output,
        grad: crate::Output,
        indices: crate::Output,
        lr: crate::Output,
        l1: crate::Output,
        l2: crate::Output,
        lr_power: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ResourceSparseApplyFtrl", |nd| {
            nd.add_input(var);
            nd.add_input(accum);
            nd.add_input(linear);
            nd.add_input(grad);
            nd.add_input(indices);
            nd.add_input(lr);
            nd.add_input(l1);
            nd.add_input(l2);
            nd.add_input(lr_power);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                nd.set_attr_type("Tindices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                nd.set_attr_bool("use_locking", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.multiply_linear_by_lr {
                nd.set_attr_bool("multiply_linear_by_lr", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ResourceSparseApplyFtrl' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        var: crate::Output,
        accum: crate::Output,
        linear: crate::Output,
        grad: crate::Output,
        indices: crate::Output,
        lr: crate::Output,
        l1: crate::Output,
        l2: crate::Output,
        lr_power: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ResourceSparseApplyFtrlInst> {
        let op = scope.new_operation("ResourceSparseApplyFtrl", |builder| {
            builder.add_input(var);
            builder.add_input(accum);
            builder.add_input(linear);
            builder.add_input(grad);
            builder.add_input(indices);
            builder.add_input(lr);
            builder.add_input(l1);
            builder.add_input(l2);
            builder.add_input(lr_power);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                builder.set_attr_type("Tindices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                builder.set_attr_bool("use_locking", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.multiply_linear_by_lr {
                builder.set_attr_bool("multiply_linear_by_lr", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ResourceSparseApplyFtrlInst { op })
    }
}
impl ResourceSparseApplyFtrlInst {
    /// Returns the 'var' Input of this 'ResourceSparseApplyFtrl' operation.
    pub fn var(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'accum' Input of this 'ResourceSparseApplyFtrl' operation.
    pub fn accum(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'linear' Input of this 'ResourceSparseApplyFtrl' operation.
    pub fn linear(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'grad' Input of this 'ResourceSparseApplyFtrl' operation.
    pub fn grad(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'indices' Input of this 'ResourceSparseApplyFtrl' operation.
    pub fn indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
    /// Returns the 'lr' Input of this 'ResourceSparseApplyFtrl' operation.
    pub fn lr(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 5,
        }
    }
    /// Returns the 'l1' Input of this 'ResourceSparseApplyFtrl' operation.
    pub fn l1(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 6,
        }
    }
    /// Returns the 'l2' Input of this 'ResourceSparseApplyFtrl' operation.
    pub fn l2(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 7,
        }
    }
    /// Returns the 'lr_power' Input of this 'ResourceSparseApplyFtrl' operation.
    pub fn lr_power(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 8,
        }
    }
}
impl From<ResourceSparseApplyFtrlInst> for crate::Operation {
    fn from(inst: ResourceSparseApplyFtrlInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ResourceSparseApplyFtrl::new().build(var, accum, linear, grad, indices, lr, l1, l2, lr_power, scope)`.
pub fn resource_sparse_apply_ftrl<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
    O6: ::std::convert::Into<crate::Output>,
    O7: ::std::convert::Into<crate::Output>,
    O8: ::std::convert::Into<crate::Output>,
>(
    var: O0,
    accum: O1,
    linear: O2,
    grad: O3,
    indices: O4,
    lr: O5,
    l1: O6,
    l2: O7,
    lr_power: O8,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ResourceSparseApplyFtrl::new().build(
        var, accum, linear, grad, indices, lr, l1, l2, lr_power, scope,
    )
}

/// Builder for the `ResourceSparseApplyFtrlV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ResourceSparseApplyFtrlV2 {
    T: ::std::option::Option<crate::DataType>,
    Tindices: ::std::option::Option<crate::DataType>,
    use_locking: ::std::option::Option<bool>,
    multiply_linear_by_lr: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ResourceSparseApplyFtrlV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ResourceSparseApplyFtrlV2Inst {
    /// An instance of a fully built ResourceSparseApplyFtrlV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ResourceSparseApplyFtrlV2 {
    /// Creates a new `ResourceSparseApplyFtrlV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tindices` attribute.
    pub fn Tindices<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tindices = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_locking` attribute.
    pub fn use_locking<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.use_locking = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `multiply_linear_by_lr` attribute.
    pub fn multiply_linear_by_lr<ArgType: ::std::convert::Into<bool>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.multiply_linear_by_lr = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ResourceSparseApplyFtrlV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
        O6: ::std::convert::Into<crate::Output>,
        O7: ::std::convert::Into<crate::Output>,
        O8: ::std::convert::Into<crate::Output>,
        O9: ::std::convert::Into<crate::Output>,
    >(
        &self,
        var: O0,
        accum: O1,
        linear: O2,
        grad: O3,
        indices: O4,
        lr: O5,
        l1: O6,
        l2: O7,
        l2_shrinkage: O8,
        lr_power: O9,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            var.into(),
            accum.into(),
            linear.into(),
            grad.into(),
            indices.into(),
            lr.into(),
            l1.into(),
            l2.into(),
            l2_shrinkage.into(),
            lr_power.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        var: crate::Output,
        accum: crate::Output,
        linear: crate::Output,
        grad: crate::Output,
        indices: crate::Output,
        lr: crate::Output,
        l1: crate::Output,
        l2: crate::Output,
        l2_shrinkage: crate::Output,
        lr_power: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ResourceSparseApplyFtrlV2", |nd| {
            nd.add_input(var);
            nd.add_input(accum);
            nd.add_input(linear);
            nd.add_input(grad);
            nd.add_input(indices);
            nd.add_input(lr);
            nd.add_input(l1);
            nd.add_input(l2);
            nd.add_input(l2_shrinkage);
            nd.add_input(lr_power);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                nd.set_attr_type("Tindices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                nd.set_attr_bool("use_locking", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.multiply_linear_by_lr {
                nd.set_attr_bool("multiply_linear_by_lr", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ResourceSparseApplyFtrlV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        var: crate::Output,
        accum: crate::Output,
        linear: crate::Output,
        grad: crate::Output,
        indices: crate::Output,
        lr: crate::Output,
        l1: crate::Output,
        l2: crate::Output,
        l2_shrinkage: crate::Output,
        lr_power: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ResourceSparseApplyFtrlV2Inst> {
        let op = scope.new_operation("ResourceSparseApplyFtrlV2", |builder| {
            builder.add_input(var);
            builder.add_input(accum);
            builder.add_input(linear);
            builder.add_input(grad);
            builder.add_input(indices);
            builder.add_input(lr);
            builder.add_input(l1);
            builder.add_input(l2);
            builder.add_input(l2_shrinkage);
            builder.add_input(lr_power);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                builder.set_attr_type("Tindices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                builder.set_attr_bool("use_locking", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.multiply_linear_by_lr {
                builder.set_attr_bool("multiply_linear_by_lr", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ResourceSparseApplyFtrlV2Inst { op })
    }
}
impl ResourceSparseApplyFtrlV2Inst {
    /// Returns the 'var' Input of this 'ResourceSparseApplyFtrlV2' operation.
    pub fn var(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'accum' Input of this 'ResourceSparseApplyFtrlV2' operation.
    pub fn accum(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'linear' Input of this 'ResourceSparseApplyFtrlV2' operation.
    pub fn linear(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'grad' Input of this 'ResourceSparseApplyFtrlV2' operation.
    pub fn grad(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'indices' Input of this 'ResourceSparseApplyFtrlV2' operation.
    pub fn indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
    /// Returns the 'lr' Input of this 'ResourceSparseApplyFtrlV2' operation.
    pub fn lr(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 5,
        }
    }
    /// Returns the 'l1' Input of this 'ResourceSparseApplyFtrlV2' operation.
    pub fn l1(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 6,
        }
    }
    /// Returns the 'l2' Input of this 'ResourceSparseApplyFtrlV2' operation.
    pub fn l2(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 7,
        }
    }
    /// Returns the 'l2_shrinkage' Input of this 'ResourceSparseApplyFtrlV2' operation.
    pub fn l2_shrinkage(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 8,
        }
    }
    /// Returns the 'lr_power' Input of this 'ResourceSparseApplyFtrlV2' operation.
    pub fn lr_power(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 9,
        }
    }
}
impl From<ResourceSparseApplyFtrlV2Inst> for crate::Operation {
    fn from(inst: ResourceSparseApplyFtrlV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ResourceSparseApplyFtrlV2::new().build(var, accum, linear, grad, indices, lr, l1, l2, l2_shrinkage, lr_power, scope)`.
pub fn resource_sparse_apply_ftrl_v2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
    O6: ::std::convert::Into<crate::Output>,
    O7: ::std::convert::Into<crate::Output>,
    O8: ::std::convert::Into<crate::Output>,
    O9: ::std::convert::Into<crate::Output>,
>(
    var: O0,
    accum: O1,
    linear: O2,
    grad: O3,
    indices: O4,
    lr: O5,
    l1: O6,
    l2: O7,
    l2_shrinkage: O8,
    lr_power: O9,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ResourceSparseApplyFtrlV2::new().build(
        var,
        accum,
        linear,
        grad,
        indices,
        lr,
        l1,
        l2,
        l2_shrinkage,
        lr_power,
        scope,
    )
}

/// Builder for the `ResourceSparseApplyKerasMomentum` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ResourceSparseApplyKerasMomentum {
    T: ::std::option::Option<crate::DataType>,
    Tindices: ::std::option::Option<crate::DataType>,
    use_locking: ::std::option::Option<bool>,
    use_nesterov: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ResourceSparseApplyKerasMomentum' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ResourceSparseApplyKerasMomentumInst {
    /// An instance of a fully built ResourceSparseApplyKerasMomentum Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ResourceSparseApplyKerasMomentum {
    /// Creates a new `ResourceSparseApplyKerasMomentum`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tindices` attribute.
    pub fn Tindices<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tindices = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_locking` attribute.
    pub fn use_locking<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.use_locking = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_nesterov` attribute.
    pub fn use_nesterov<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.use_nesterov = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ResourceSparseApplyKerasMomentum` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
    >(
        &self,
        var: O0,
        accum: O1,
        lr: O2,
        grad: O3,
        indices: O4,
        momentum: O5,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            var.into(),
            accum.into(),
            lr.into(),
            grad.into(),
            indices.into(),
            momentum.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        var: crate::Output,
        accum: crate::Output,
        lr: crate::Output,
        grad: crate::Output,
        indices: crate::Output,
        momentum: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ResourceSparseApplyKerasMomentum", |nd| {
            nd.add_input(var);
            nd.add_input(accum);
            nd.add_input(lr);
            nd.add_input(grad);
            nd.add_input(indices);
            nd.add_input(momentum);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                nd.set_attr_type("Tindices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                nd.set_attr_bool("use_locking", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_nesterov {
                nd.set_attr_bool("use_nesterov", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ResourceSparseApplyKerasMomentum' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        var: crate::Output,
        accum: crate::Output,
        lr: crate::Output,
        grad: crate::Output,
        indices: crate::Output,
        momentum: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ResourceSparseApplyKerasMomentumInst> {
        let op = scope.new_operation("ResourceSparseApplyKerasMomentum", |builder| {
            builder.add_input(var);
            builder.add_input(accum);
            builder.add_input(lr);
            builder.add_input(grad);
            builder.add_input(indices);
            builder.add_input(momentum);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                builder.set_attr_type("Tindices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                builder.set_attr_bool("use_locking", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_nesterov {
                builder.set_attr_bool("use_nesterov", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ResourceSparseApplyKerasMomentumInst { op })
    }
}
impl ResourceSparseApplyKerasMomentumInst {
    /// Returns the 'var' Input of this 'ResourceSparseApplyKerasMomentum' operation.
    pub fn var(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'accum' Input of this 'ResourceSparseApplyKerasMomentum' operation.
    pub fn accum(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'lr' Input of this 'ResourceSparseApplyKerasMomentum' operation.
    pub fn lr(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'grad' Input of this 'ResourceSparseApplyKerasMomentum' operation.
    pub fn grad(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'indices' Input of this 'ResourceSparseApplyKerasMomentum' operation.
    pub fn indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
    /// Returns the 'momentum' Input of this 'ResourceSparseApplyKerasMomentum' operation.
    pub fn momentum(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 5,
        }
    }
}
impl From<ResourceSparseApplyKerasMomentumInst> for crate::Operation {
    fn from(inst: ResourceSparseApplyKerasMomentumInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ResourceSparseApplyKerasMomentum::new().build(var, accum, lr, grad, indices, momentum, scope)`.
pub fn resource_sparse_apply_keras_momentum<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
>(
    var: O0,
    accum: O1,
    lr: O2,
    grad: O3,
    indices: O4,
    momentum: O5,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ResourceSparseApplyKerasMomentum::new().build(var, accum, lr, grad, indices, momentum, scope)
}

/// Builder for the `ResourceSparseApplyMomentum` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ResourceSparseApplyMomentum {
    T: ::std::option::Option<crate::DataType>,
    Tindices: ::std::option::Option<crate::DataType>,
    use_locking: ::std::option::Option<bool>,
    use_nesterov: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ResourceSparseApplyMomentum' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ResourceSparseApplyMomentumInst {
    /// An instance of a fully built ResourceSparseApplyMomentum Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ResourceSparseApplyMomentum {
    /// Creates a new `ResourceSparseApplyMomentum`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tindices` attribute.
    pub fn Tindices<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tindices = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_locking` attribute.
    pub fn use_locking<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.use_locking = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_nesterov` attribute.
    pub fn use_nesterov<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.use_nesterov = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ResourceSparseApplyMomentum` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
    >(
        &self,
        var: O0,
        accum: O1,
        lr: O2,
        grad: O3,
        indices: O4,
        momentum: O5,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            var.into(),
            accum.into(),
            lr.into(),
            grad.into(),
            indices.into(),
            momentum.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        var: crate::Output,
        accum: crate::Output,
        lr: crate::Output,
        grad: crate::Output,
        indices: crate::Output,
        momentum: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ResourceSparseApplyMomentum", |nd| {
            nd.add_input(var);
            nd.add_input(accum);
            nd.add_input(lr);
            nd.add_input(grad);
            nd.add_input(indices);
            nd.add_input(momentum);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                nd.set_attr_type("Tindices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                nd.set_attr_bool("use_locking", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_nesterov {
                nd.set_attr_bool("use_nesterov", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ResourceSparseApplyMomentum' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        var: crate::Output,
        accum: crate::Output,
        lr: crate::Output,
        grad: crate::Output,
        indices: crate::Output,
        momentum: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ResourceSparseApplyMomentumInst> {
        let op = scope.new_operation("ResourceSparseApplyMomentum", |builder| {
            builder.add_input(var);
            builder.add_input(accum);
            builder.add_input(lr);
            builder.add_input(grad);
            builder.add_input(indices);
            builder.add_input(momentum);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                builder.set_attr_type("Tindices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                builder.set_attr_bool("use_locking", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_nesterov {
                builder.set_attr_bool("use_nesterov", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ResourceSparseApplyMomentumInst { op })
    }
}
impl ResourceSparseApplyMomentumInst {
    /// Returns the 'var' Input of this 'ResourceSparseApplyMomentum' operation.
    pub fn var(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'accum' Input of this 'ResourceSparseApplyMomentum' operation.
    pub fn accum(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'lr' Input of this 'ResourceSparseApplyMomentum' operation.
    pub fn lr(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'grad' Input of this 'ResourceSparseApplyMomentum' operation.
    pub fn grad(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'indices' Input of this 'ResourceSparseApplyMomentum' operation.
    pub fn indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
    /// Returns the 'momentum' Input of this 'ResourceSparseApplyMomentum' operation.
    pub fn momentum(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 5,
        }
    }
}
impl From<ResourceSparseApplyMomentumInst> for crate::Operation {
    fn from(inst: ResourceSparseApplyMomentumInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ResourceSparseApplyMomentum::new().build(var, accum, lr, grad, indices, momentum, scope)`.
pub fn resource_sparse_apply_momentum<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
>(
    var: O0,
    accum: O1,
    lr: O2,
    grad: O3,
    indices: O4,
    momentum: O5,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ResourceSparseApplyMomentum::new().build(var, accum, lr, grad, indices, momentum, scope)
}

/// Builder for the `ResourceSparseApplyProximalAdagrad` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ResourceSparseApplyProximalAdagrad {
    T: ::std::option::Option<crate::DataType>,
    Tindices: ::std::option::Option<crate::DataType>,
    use_locking: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ResourceSparseApplyProximalAdagrad' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ResourceSparseApplyProximalAdagradInst {
    /// An instance of a fully built ResourceSparseApplyProximalAdagrad Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ResourceSparseApplyProximalAdagrad {
    /// Creates a new `ResourceSparseApplyProximalAdagrad`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tindices` attribute.
    pub fn Tindices<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tindices = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_locking` attribute.
    pub fn use_locking<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.use_locking = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ResourceSparseApplyProximalAdagrad` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
        O6: ::std::convert::Into<crate::Output>,
    >(
        &self,
        var: O0,
        accum: O1,
        lr: O2,
        l1: O3,
        l2: O4,
        grad: O5,
        indices: O6,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            var.into(),
            accum.into(),
            lr.into(),
            l1.into(),
            l2.into(),
            grad.into(),
            indices.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        var: crate::Output,
        accum: crate::Output,
        lr: crate::Output,
        l1: crate::Output,
        l2: crate::Output,
        grad: crate::Output,
        indices: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ResourceSparseApplyProximalAdagrad", |nd| {
            nd.add_input(var);
            nd.add_input(accum);
            nd.add_input(lr);
            nd.add_input(l1);
            nd.add_input(l2);
            nd.add_input(grad);
            nd.add_input(indices);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                nd.set_attr_type("Tindices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                nd.set_attr_bool("use_locking", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ResourceSparseApplyProximalAdagrad' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        var: crate::Output,
        accum: crate::Output,
        lr: crate::Output,
        l1: crate::Output,
        l2: crate::Output,
        grad: crate::Output,
        indices: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ResourceSparseApplyProximalAdagradInst> {
        let op = scope.new_operation("ResourceSparseApplyProximalAdagrad", |builder| {
            builder.add_input(var);
            builder.add_input(accum);
            builder.add_input(lr);
            builder.add_input(l1);
            builder.add_input(l2);
            builder.add_input(grad);
            builder.add_input(indices);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                builder.set_attr_type("Tindices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                builder.set_attr_bool("use_locking", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ResourceSparseApplyProximalAdagradInst { op })
    }
}
impl ResourceSparseApplyProximalAdagradInst {
    /// Returns the 'var' Input of this 'ResourceSparseApplyProximalAdagrad' operation.
    pub fn var(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'accum' Input of this 'ResourceSparseApplyProximalAdagrad' operation.
    pub fn accum(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'lr' Input of this 'ResourceSparseApplyProximalAdagrad' operation.
    pub fn lr(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'l1' Input of this 'ResourceSparseApplyProximalAdagrad' operation.
    pub fn l1(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'l2' Input of this 'ResourceSparseApplyProximalAdagrad' operation.
    pub fn l2(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
    /// Returns the 'grad' Input of this 'ResourceSparseApplyProximalAdagrad' operation.
    pub fn grad(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 5,
        }
    }
    /// Returns the 'indices' Input of this 'ResourceSparseApplyProximalAdagrad' operation.
    pub fn indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 6,
        }
    }
}
impl From<ResourceSparseApplyProximalAdagradInst> for crate::Operation {
    fn from(inst: ResourceSparseApplyProximalAdagradInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ResourceSparseApplyProximalAdagrad::new().build(var, accum, lr, l1, l2, grad, indices, scope)`.
pub fn resource_sparse_apply_proximal_adagrad<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
    O6: ::std::convert::Into<crate::Output>,
>(
    var: O0,
    accum: O1,
    lr: O2,
    l1: O3,
    l2: O4,
    grad: O5,
    indices: O6,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ResourceSparseApplyProximalAdagrad::new().build(var, accum, lr, l1, l2, grad, indices, scope)
}

/// Builder for the `ResourceSparseApplyProximalGradientDescent` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ResourceSparseApplyProximalGradientDescent {
    T: ::std::option::Option<crate::DataType>,
    Tindices: ::std::option::Option<crate::DataType>,
    use_locking: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ResourceSparseApplyProximalGradientDescent' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ResourceSparseApplyProximalGradientDescentInst {
    /// An instance of a fully built ResourceSparseApplyProximalGradientDescent Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ResourceSparseApplyProximalGradientDescent {
    /// Creates a new `ResourceSparseApplyProximalGradientDescent`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tindices` attribute.
    pub fn Tindices<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tindices = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_locking` attribute.
    pub fn use_locking<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.use_locking = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ResourceSparseApplyProximalGradientDescent` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
    >(
        &self,
        var: O0,
        alpha: O1,
        l1: O2,
        l2: O3,
        grad: O4,
        indices: O5,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            var.into(),
            alpha.into(),
            l1.into(),
            l2.into(),
            grad.into(),
            indices.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        var: crate::Output,
        alpha: crate::Output,
        l1: crate::Output,
        l2: crate::Output,
        grad: crate::Output,
        indices: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ResourceSparseApplyProximalGradientDescent", |nd| {
            nd.add_input(var);
            nd.add_input(alpha);
            nd.add_input(l1);
            nd.add_input(l2);
            nd.add_input(grad);
            nd.add_input(indices);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                nd.set_attr_type("Tindices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                nd.set_attr_bool("use_locking", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ResourceSparseApplyProximalGradientDescent' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        var: crate::Output,
        alpha: crate::Output,
        l1: crate::Output,
        l2: crate::Output,
        grad: crate::Output,
        indices: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ResourceSparseApplyProximalGradientDescentInst> {
        let op = scope.new_operation("ResourceSparseApplyProximalGradientDescent", |builder| {
            builder.add_input(var);
            builder.add_input(alpha);
            builder.add_input(l1);
            builder.add_input(l2);
            builder.add_input(grad);
            builder.add_input(indices);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                builder.set_attr_type("Tindices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                builder.set_attr_bool("use_locking", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ResourceSparseApplyProximalGradientDescentInst { op })
    }
}
impl ResourceSparseApplyProximalGradientDescentInst {
    /// Returns the 'var' Input of this 'ResourceSparseApplyProximalGradientDescent' operation.
    pub fn var(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'alpha' Input of this 'ResourceSparseApplyProximalGradientDescent' operation.
    pub fn alpha(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'l1' Input of this 'ResourceSparseApplyProximalGradientDescent' operation.
    pub fn l1(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'l2' Input of this 'ResourceSparseApplyProximalGradientDescent' operation.
    pub fn l2(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'grad' Input of this 'ResourceSparseApplyProximalGradientDescent' operation.
    pub fn grad(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
    /// Returns the 'indices' Input of this 'ResourceSparseApplyProximalGradientDescent' operation.
    pub fn indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 5,
        }
    }
}
impl From<ResourceSparseApplyProximalGradientDescentInst> for crate::Operation {
    fn from(inst: ResourceSparseApplyProximalGradientDescentInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ResourceSparseApplyProximalGradientDescent::new().build(var, alpha, l1, l2, grad, indices, scope)`.
pub fn resource_sparse_apply_proximal_gradient_descent<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
>(
    var: O0,
    alpha: O1,
    l1: O2,
    l2: O3,
    grad: O4,
    indices: O5,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ResourceSparseApplyProximalGradientDescent::new()
        .build(var, alpha, l1, l2, grad, indices, scope)
}

/// Builder for the `ResourceSparseApplyRMSProp` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ResourceSparseApplyRMSProp {
    T: ::std::option::Option<crate::DataType>,
    Tindices: ::std::option::Option<crate::DataType>,
    use_locking: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ResourceSparseApplyRMSProp' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ResourceSparseApplyRMSPropInst {
    /// An instance of a fully built ResourceSparseApplyRMSProp Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ResourceSparseApplyRMSProp {
    /// Creates a new `ResourceSparseApplyRMSProp`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tindices` attribute.
    pub fn Tindices<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tindices = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_locking` attribute.
    pub fn use_locking<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.use_locking = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ResourceSparseApplyRMSProp` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
        O6: ::std::convert::Into<crate::Output>,
        O7: ::std::convert::Into<crate::Output>,
        O8: ::std::convert::Into<crate::Output>,
    >(
        &self,
        var: O0,
        ms: O1,
        mom: O2,
        lr: O3,
        rho: O4,
        momentum: O5,
        epsilon: O6,
        grad: O7,
        indices: O8,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            var.into(),
            ms.into(),
            mom.into(),
            lr.into(),
            rho.into(),
            momentum.into(),
            epsilon.into(),
            grad.into(),
            indices.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        var: crate::Output,
        ms: crate::Output,
        mom: crate::Output,
        lr: crate::Output,
        rho: crate::Output,
        momentum: crate::Output,
        epsilon: crate::Output,
        grad: crate::Output,
        indices: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ResourceSparseApplyRMSProp", |nd| {
            nd.add_input(var);
            nd.add_input(ms);
            nd.add_input(mom);
            nd.add_input(lr);
            nd.add_input(rho);
            nd.add_input(momentum);
            nd.add_input(epsilon);
            nd.add_input(grad);
            nd.add_input(indices);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                nd.set_attr_type("Tindices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                nd.set_attr_bool("use_locking", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ResourceSparseApplyRMSProp' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        var: crate::Output,
        ms: crate::Output,
        mom: crate::Output,
        lr: crate::Output,
        rho: crate::Output,
        momentum: crate::Output,
        epsilon: crate::Output,
        grad: crate::Output,
        indices: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ResourceSparseApplyRMSPropInst> {
        let op = scope.new_operation("ResourceSparseApplyRMSProp", |builder| {
            builder.add_input(var);
            builder.add_input(ms);
            builder.add_input(mom);
            builder.add_input(lr);
            builder.add_input(rho);
            builder.add_input(momentum);
            builder.add_input(epsilon);
            builder.add_input(grad);
            builder.add_input(indices);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                builder.set_attr_type("Tindices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                builder.set_attr_bool("use_locking", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ResourceSparseApplyRMSPropInst { op })
    }
}
impl ResourceSparseApplyRMSPropInst {
    /// Returns the 'var' Input of this 'ResourceSparseApplyRMSProp' operation.
    pub fn var(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'ms' Input of this 'ResourceSparseApplyRMSProp' operation.
    pub fn ms(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'mom' Input of this 'ResourceSparseApplyRMSProp' operation.
    pub fn mom(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'lr' Input of this 'ResourceSparseApplyRMSProp' operation.
    pub fn lr(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'rho' Input of this 'ResourceSparseApplyRMSProp' operation.
    pub fn rho(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
    /// Returns the 'momentum' Input of this 'ResourceSparseApplyRMSProp' operation.
    pub fn momentum(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 5,
        }
    }
    /// Returns the 'epsilon' Input of this 'ResourceSparseApplyRMSProp' operation.
    pub fn epsilon(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 6,
        }
    }
    /// Returns the 'grad' Input of this 'ResourceSparseApplyRMSProp' operation.
    pub fn grad(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 7,
        }
    }
    /// Returns the 'indices' Input of this 'ResourceSparseApplyRMSProp' operation.
    pub fn indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 8,
        }
    }
}
impl From<ResourceSparseApplyRMSPropInst> for crate::Operation {
    fn from(inst: ResourceSparseApplyRMSPropInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ResourceSparseApplyRMSProp::new().build(var, ms, mom, lr, rho, momentum, epsilon, grad, indices, scope)`.
pub fn resource_sparse_apply_rmsprop<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
    O6: ::std::convert::Into<crate::Output>,
    O7: ::std::convert::Into<crate::Output>,
    O8: ::std::convert::Into<crate::Output>,
>(
    var: O0,
    ms: O1,
    mom: O2,
    lr: O3,
    rho: O4,
    momentum: O5,
    epsilon: O6,
    grad: O7,
    indices: O8,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ResourceSparseApplyRMSProp::new().build(
        var, ms, mom, lr, rho, momentum, epsilon, grad, indices, scope,
    )
}

/// Builder for the `ResourceStridedSliceAssign` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ResourceStridedSliceAssign {
    T: ::std::option::Option<crate::DataType>,
    Index: ::std::option::Option<crate::DataType>,
    begin_mask: ::std::option::Option<i64>,
    end_mask: ::std::option::Option<i64>,
    ellipsis_mask: ::std::option::Option<i64>,
    new_axis_mask: ::std::option::Option<i64>,
    shrink_axis_mask: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ResourceStridedSliceAssign' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ResourceStridedSliceAssignInst {
    /// An instance of a fully built ResourceStridedSliceAssign Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ResourceStridedSliceAssign {
    /// Creates a new `ResourceStridedSliceAssign`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Index` attribute.
    pub fn Index<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Index = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `begin_mask` attribute.
    pub fn begin_mask<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.begin_mask = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `end_mask` attribute.
    pub fn end_mask<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.end_mask = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `ellipsis_mask` attribute.
    pub fn ellipsis_mask<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.ellipsis_mask = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `new_axis_mask` attribute.
    pub fn new_axis_mask<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.new_axis_mask = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shrink_axis_mask` attribute.
    pub fn shrink_axis_mask<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.shrink_axis_mask = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ResourceStridedSliceAssign` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
    >(
        &self,
        ref_: O0,
        begin: O1,
        end: O2,
        strides: O3,
        value: O4,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            ref_.into(),
            begin.into(),
            end.into(),
            strides.into(),
            value.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        ref_: crate::Output,
        begin: crate::Output,
        end: crate::Output,
        strides: crate::Output,
        value: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ResourceStridedSliceAssign", |nd| {
            nd.add_input(ref_);
            nd.add_input(begin);
            nd.add_input(end);
            nd.add_input(strides);
            nd.add_input(value);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Index {
                nd.set_attr_type("Index", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.begin_mask {
                nd.set_attr_int("begin_mask", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.end_mask {
                nd.set_attr_int("end_mask", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.ellipsis_mask {
                nd.set_attr_int("ellipsis_mask", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.new_axis_mask {
                nd.set_attr_int("new_axis_mask", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shrink_axis_mask {
                nd.set_attr_int("shrink_axis_mask", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ResourceStridedSliceAssign' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        ref_: crate::Output,
        begin: crate::Output,
        end: crate::Output,
        strides: crate::Output,
        value: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ResourceStridedSliceAssignInst> {
        let op = scope.new_operation("ResourceStridedSliceAssign", |builder| {
            builder.add_input(ref_);
            builder.add_input(begin);
            builder.add_input(end);
            builder.add_input(strides);
            builder.add_input(value);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Index {
                builder.set_attr_type("Index", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.begin_mask {
                builder.set_attr_int("begin_mask", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.end_mask {
                builder.set_attr_int("end_mask", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.ellipsis_mask {
                builder.set_attr_int("ellipsis_mask", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.new_axis_mask {
                builder.set_attr_int("new_axis_mask", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shrink_axis_mask {
                builder.set_attr_int("shrink_axis_mask", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ResourceStridedSliceAssignInst { op })
    }
}
impl ResourceStridedSliceAssignInst {
    /// Returns the 'ref_' Input of this 'ResourceStridedSliceAssign' operation.
    pub fn ref_(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'begin' Input of this 'ResourceStridedSliceAssign' operation.
    pub fn begin(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'end' Input of this 'ResourceStridedSliceAssign' operation.
    pub fn end(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'strides' Input of this 'ResourceStridedSliceAssign' operation.
    pub fn strides(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'value' Input of this 'ResourceStridedSliceAssign' operation.
    pub fn value(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
}
impl From<ResourceStridedSliceAssignInst> for crate::Operation {
    fn from(inst: ResourceStridedSliceAssignInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ResourceStridedSliceAssign::new().build(ref_, begin, end, strides, value, scope)`.
pub fn resource_strided_slice_assign<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
>(
    ref_: O0,
    begin: O1,
    end: O2,
    strides: O3,
    value: O4,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ResourceStridedSliceAssign::new().build(ref_, begin, end, strides, value, scope)
}

/// Builder for the `Restore` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Restore {
    dt: ::std::option::Option<crate::DataType>,
    preferred_shard: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Restore' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RestoreInst {
    /// An instance of a fully built Restore Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Restore {
    /// Creates a new `Restore`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `dt` attribute.
    pub fn dt<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.dt = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `preferred_shard` attribute.
    pub fn preferred_shard<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.preferred_shard = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Restore` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        file_pattern: O0,
        tensor_name: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(file_pattern.into(), tensor_name.into(), scope)
    }
    fn build_impl(
        &self,
        file_pattern: crate::Output,
        tensor_name: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Restore", |nd| {
            nd.add_input(file_pattern);
            nd.add_input(tensor_name);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.dt {
                nd.set_attr_type("dt", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.preferred_shard {
                nd.set_attr_int("preferred_shard", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Restore' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        file_pattern: crate::Output,
        tensor_name: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<RestoreInst> {
        let op = scope.new_operation("Restore", |builder| {
            builder.add_input(file_pattern);
            builder.add_input(tensor_name);
            if let ::std::option::Option::Some(value) = &self.dt {
                builder.set_attr_type("dt", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.preferred_shard {
                builder.set_attr_int("preferred_shard", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RestoreInst { op })
    }
}
impl RestoreInst {
    /// Returns the 'tensor' Output of this 'Restore' operation.
    pub fn tensor(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'file_pattern' Input of this 'Restore' operation.
    pub fn file_pattern(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'tensor_name' Input of this 'Restore' operation.
    pub fn tensor_name(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<RestoreInst> for crate::Operation {
    fn from(inst: RestoreInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Restore::new().build(file_pattern, tensor_name, scope)`.
pub fn restore<O0: ::std::convert::Into<crate::Output>, O1: ::std::convert::Into<crate::Output>>(
    file_pattern: O0,
    tensor_name: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Restore::new().build(file_pattern, tensor_name, scope)
}

/// Builder for the `RestoreSlice` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RestoreSlice {
    dt: ::std::option::Option<crate::DataType>,
    preferred_shard: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RestoreSlice' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RestoreSliceInst {
    /// An instance of a fully built RestoreSlice Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RestoreSlice {
    /// Creates a new `RestoreSlice`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `dt` attribute.
    pub fn dt<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.dt = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `preferred_shard` attribute.
    pub fn preferred_shard<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.preferred_shard = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RestoreSlice` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        file_pattern: O0,
        tensor_name: O1,
        shape_and_slice: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            file_pattern.into(),
            tensor_name.into(),
            shape_and_slice.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        file_pattern: crate::Output,
        tensor_name: crate::Output,
        shape_and_slice: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("RestoreSlice", |nd| {
            nd.add_input(file_pattern);
            nd.add_input(tensor_name);
            nd.add_input(shape_and_slice);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.dt {
                nd.set_attr_type("dt", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.preferred_shard {
                nd.set_attr_int("preferred_shard", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RestoreSlice' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        file_pattern: crate::Output,
        tensor_name: crate::Output,
        shape_and_slice: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<RestoreSliceInst> {
        let op = scope.new_operation("RestoreSlice", |builder| {
            builder.add_input(file_pattern);
            builder.add_input(tensor_name);
            builder.add_input(shape_and_slice);
            if let ::std::option::Option::Some(value) = &self.dt {
                builder.set_attr_type("dt", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.preferred_shard {
                builder.set_attr_int("preferred_shard", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RestoreSliceInst { op })
    }
}
impl RestoreSliceInst {
    /// Returns the 'tensor' Output of this 'RestoreSlice' operation.
    pub fn tensor(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'file_pattern' Input of this 'RestoreSlice' operation.
    pub fn file_pattern(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'tensor_name' Input of this 'RestoreSlice' operation.
    pub fn tensor_name(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'shape_and_slice' Input of this 'RestoreSlice' operation.
    pub fn shape_and_slice(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<RestoreSliceInst> for crate::Operation {
    fn from(inst: RestoreSliceInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RestoreSlice::new().build(file_pattern, tensor_name, shape_and_slice, scope)`.
pub fn restore_slice<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    file_pattern: O0,
    tensor_name: O1,
    shape_and_slice: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RestoreSlice::new().build(file_pattern, tensor_name, shape_and_slice, scope)
}

/// Builder for the `RestoreV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RestoreV2 {
    dtypes: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RestoreV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RestoreV2Inst {
    /// An instance of a fully built RestoreV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RestoreV2 {
    /// Creates a new `RestoreV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `dtypes` attribute.
    pub fn dtypes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.dtypes = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RestoreV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        prefix: O0,
        tensor_names: O1,
        shape_and_slices: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            prefix.into(),
            tensor_names.into(),
            shape_and_slices.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        prefix: crate::Output,
        tensor_names: crate::Output,
        shape_and_slices: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("RestoreV2", |nd| {
            nd.add_input(prefix);
            nd.add_input(tensor_names);
            nd.add_input(shape_and_slices);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.dtypes {
                nd.set_attr_type_list("dtypes", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RestoreV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        prefix: crate::Output,
        tensor_names: crate::Output,
        shape_and_slices: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<RestoreV2Inst> {
        let op = scope.new_operation("RestoreV2", |builder| {
            builder.add_input(prefix);
            builder.add_input(tensor_names);
            builder.add_input(shape_and_slices);
            if let ::std::option::Option::Some(value) = &self.dtypes {
                builder.set_attr_type_list("dtypes", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RestoreV2Inst { op })
    }
}
impl RestoreV2Inst {
    /// Returns the 'tensors' Output of this 'RestoreV2' operation.
    pub fn tensors(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'prefix' Input of this 'RestoreV2' operation.
    pub fn prefix(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'tensor_names' Input of this 'RestoreV2' operation.
    pub fn tensor_names(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'shape_and_slices' Input of this 'RestoreV2' operation.
    pub fn shape_and_slices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<RestoreV2Inst> for crate::Operation {
    fn from(inst: RestoreV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RestoreV2::new().build(prefix, tensor_names, shape_and_slices, scope)`.
pub fn restore_v2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    prefix: O0,
    tensor_names: O1,
    shape_and_slices: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RestoreV2::new().build(prefix, tensor_names, shape_and_slices, scope)
}

/// Builder for the `RetrieveAllTPUEmbeddingParameters` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RetrieveAllTPUEmbeddingParameters {
    NumTables: ::std::option::Option<i64>,
    config: ::std::option::Option<::std::string::String>,
    num_shards: ::std::option::Option<i64>,
    shard_id: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RetrieveAllTPUEmbeddingParameters' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RetrieveAllTPUEmbeddingParametersInst {
    /// An instance of a fully built RetrieveAllTPUEmbeddingParameters Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RetrieveAllTPUEmbeddingParameters {
    /// Creates a new `RetrieveAllTPUEmbeddingParameters`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `NumTables` attribute.
    pub fn NumTables<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.NumTables = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `config` attribute.
    pub fn config<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.config = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `num_shards` attribute.
    pub fn num_shards<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.num_shards = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shard_id` attribute.
    pub fn shard_id<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.shard_id = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RetrieveAllTPUEmbeddingParameters` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("RetrieveAllTPUEmbeddingParameters", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.NumTables {
                nd.set_attr_int("NumTables", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.config {
                nd.set_attr_string("config", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_shards {
                nd.set_attr_int("num_shards", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shard_id {
                nd.set_attr_int("shard_id", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RetrieveAllTPUEmbeddingParameters' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        scope: &mut crate::Scope,
    ) -> crate::Result<RetrieveAllTPUEmbeddingParametersInst> {
        let op = scope.new_operation("RetrieveAllTPUEmbeddingParameters", |builder| {
            if let ::std::option::Option::Some(value) = &self.NumTables {
                builder.set_attr_int("NumTables", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.config {
                builder.set_attr_string("config", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_shards {
                builder.set_attr_int("num_shards", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shard_id {
                builder.set_attr_int("shard_id", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RetrieveAllTPUEmbeddingParametersInst { op })
    }
}
impl RetrieveAllTPUEmbeddingParametersInst {
    /// Returns a Vector of parameters for 'parameters' Output of this RetrieveAllTPUEmbeddingParameters operation.
    pub fn parameters(&self) -> crate::Result<Vec<crate::Output>> {
        let mut Outputs = vec![];
        for i in 0..self.op.get_attr_int("NumTables")? as i32 {
            Outputs.push(crate::Output {
                operation: self.op.clone(),
                index: i,
            });
        }
        Ok(Outputs)
    }
    /// Returns a Vector of auxiliary1 for 'auxiliary1' Output of this RetrieveAllTPUEmbeddingParameters operation.
    pub fn auxiliary1(&self) -> crate::Result<Vec<crate::Output>> {
        let dynamic_offset = (self.op.get_attr_int("NumTables")? + 1) as i32;
        let mut Outputs = vec![];
        for i in dynamic_offset..dynamic_offset + self.op.get_attr_int("NumTables")? as i32 {
            Outputs.push(crate::Output {
                operation: self.op.clone(),
                index: i,
            });
        }
        Ok(Outputs)
    }
    /// Returns a Vector of auxiliary2 for 'auxiliary2' Output of this RetrieveAllTPUEmbeddingParameters operation.
    pub fn auxiliary2(&self) -> crate::Result<Vec<crate::Output>> {
        let dynamic_offset = (2 * self.op.get_attr_int("NumTables")? + 2) as i32;
        let mut Outputs = vec![];
        for i in dynamic_offset..dynamic_offset + self.op.get_attr_int("NumTables")? as i32 {
            Outputs.push(crate::Output {
                operation: self.op.clone(),
                index: i,
            });
        }
        Ok(Outputs)
    }
    /// Returns a Vector of auxiliary3 for 'auxiliary3' Output of this RetrieveAllTPUEmbeddingParameters operation.
    pub fn auxiliary3(&self) -> crate::Result<Vec<crate::Output>> {
        let dynamic_offset = (3 * self.op.get_attr_int("NumTables")? + 3) as i32;
        let mut Outputs = vec![];
        for i in dynamic_offset..dynamic_offset + self.op.get_attr_int("NumTables")? as i32 {
            Outputs.push(crate::Output {
                operation: self.op.clone(),
                index: i,
            });
        }
        Ok(Outputs)
    }
    /// Returns a Vector of auxiliary4 for 'auxiliary4' Output of this RetrieveAllTPUEmbeddingParameters operation.
    pub fn auxiliary4(&self) -> crate::Result<Vec<crate::Output>> {
        let dynamic_offset = (4 * self.op.get_attr_int("NumTables")? + 4) as i32;
        let mut Outputs = vec![];
        for i in dynamic_offset..dynamic_offset + self.op.get_attr_int("NumTables")? as i32 {
            Outputs.push(crate::Output {
                operation: self.op.clone(),
                index: i,
            });
        }
        Ok(Outputs)
    }
    /// Returns a Vector of auxiliary5 for 'auxiliary5' Output of this RetrieveAllTPUEmbeddingParameters operation.
    pub fn auxiliary5(&self) -> crate::Result<Vec<crate::Output>> {
        let dynamic_offset = (5 * self.op.get_attr_int("NumTables")? + 5) as i32;
        let mut Outputs = vec![];
        for i in dynamic_offset..dynamic_offset + self.op.get_attr_int("NumTables")? as i32 {
            Outputs.push(crate::Output {
                operation: self.op.clone(),
                index: i,
            });
        }
        Ok(Outputs)
    }
    /// Returns a Vector of auxiliary6 for 'auxiliary6' Output of this RetrieveAllTPUEmbeddingParameters operation.
    pub fn auxiliary6(&self) -> crate::Result<Vec<crate::Output>> {
        let dynamic_offset = (6 * self.op.get_attr_int("NumTables")? + 6) as i32;
        let mut Outputs = vec![];
        for i in dynamic_offset..dynamic_offset + self.op.get_attr_int("NumTables")? as i32 {
            Outputs.push(crate::Output {
                operation: self.op.clone(),
                index: i,
            });
        }
        Ok(Outputs)
    }
    /// Returns a Vector of auxiliary7 for 'auxiliary7' Output of this RetrieveAllTPUEmbeddingParameters operation.
    pub fn auxiliary7(&self) -> crate::Result<Vec<crate::Output>> {
        let dynamic_offset = (7 * self.op.get_attr_int("NumTables")? + 7) as i32;
        let mut Outputs = vec![];
        for i in dynamic_offset..dynamic_offset + self.op.get_attr_int("NumTables")? as i32 {
            Outputs.push(crate::Output {
                operation: self.op.clone(),
                index: i,
            });
        }
        Ok(Outputs)
    }
}
impl From<RetrieveAllTPUEmbeddingParametersInst> for crate::Operation {
    fn from(inst: RetrieveAllTPUEmbeddingParametersInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RetrieveAllTPUEmbeddingParameters::new().build(scope)`.
pub fn retrieve_all_tpuembedding_parameters(
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RetrieveAllTPUEmbeddingParameters::new().build(scope)
}

/// Builder for the `RetrieveTPUEmbeddingADAMParameters` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RetrieveTPUEmbeddingADAMParameters {
    table_id: ::std::option::Option<i64>,
    table_name: ::std::option::Option<::std::string::String>,
    num_shards: ::std::option::Option<i64>,
    shard_id: ::std::option::Option<i64>,
    config: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RetrieveTPUEmbeddingADAMParameters' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RetrieveTPUEmbeddingADAMParametersInst {
    /// An instance of a fully built RetrieveTPUEmbeddingADAMParameters Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RetrieveTPUEmbeddingADAMParameters {
    /// Creates a new `RetrieveTPUEmbeddingADAMParameters`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `table_id` attribute.
    pub fn table_id<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.table_id = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `table_name` attribute.
    pub fn table_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.table_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `num_shards` attribute.
    pub fn num_shards<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.num_shards = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shard_id` attribute.
    pub fn shard_id<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.shard_id = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `config` attribute.
    pub fn config<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.config = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RetrieveTPUEmbeddingADAMParameters` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("RetrieveTPUEmbeddingADAMParameters", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.table_id {
                nd.set_attr_int("table_id", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.table_name {
                nd.set_attr_string("table_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_shards {
                nd.set_attr_int("num_shards", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shard_id {
                nd.set_attr_int("shard_id", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.config {
                nd.set_attr_string("config", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RetrieveTPUEmbeddingADAMParameters' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        scope: &mut crate::Scope,
    ) -> crate::Result<RetrieveTPUEmbeddingADAMParametersInst> {
        let op = scope.new_operation("RetrieveTPUEmbeddingADAMParameters", |builder| {
            if let ::std::option::Option::Some(value) = &self.table_id {
                builder.set_attr_int("table_id", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.table_name {
                builder.set_attr_string("table_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_shards {
                builder.set_attr_int("num_shards", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shard_id {
                builder.set_attr_int("shard_id", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.config {
                builder.set_attr_string("config", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RetrieveTPUEmbeddingADAMParametersInst { op })
    }
}
impl RetrieveTPUEmbeddingADAMParametersInst {
    /// Returns the 'parameters' Output of this 'RetrieveTPUEmbeddingADAMParameters' operation.
    pub fn parameters(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'momenta' Output of this 'RetrieveTPUEmbeddingADAMParameters' operation.
    pub fn momenta(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'velocities' Output of this 'RetrieveTPUEmbeddingADAMParameters' operation.
    pub fn velocities(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
}
impl From<RetrieveTPUEmbeddingADAMParametersInst> for crate::Operation {
    fn from(inst: RetrieveTPUEmbeddingADAMParametersInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RetrieveTPUEmbeddingADAMParameters::new().build(scope)`.
pub fn retrieve_tpuembedding_adamparameters(
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RetrieveTPUEmbeddingADAMParameters::new().build(scope)
}

/// Builder for the `RetrieveTPUEmbeddingAdadeltaParameters` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RetrieveTPUEmbeddingAdadeltaParameters {
    table_id: ::std::option::Option<i64>,
    table_name: ::std::option::Option<::std::string::String>,
    num_shards: ::std::option::Option<i64>,
    shard_id: ::std::option::Option<i64>,
    config: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RetrieveTPUEmbeddingAdadeltaParameters' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RetrieveTPUEmbeddingAdadeltaParametersInst {
    /// An instance of a fully built RetrieveTPUEmbeddingAdadeltaParameters Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RetrieveTPUEmbeddingAdadeltaParameters {
    /// Creates a new `RetrieveTPUEmbeddingAdadeltaParameters`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `table_id` attribute.
    pub fn table_id<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.table_id = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `table_name` attribute.
    pub fn table_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.table_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `num_shards` attribute.
    pub fn num_shards<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.num_shards = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shard_id` attribute.
    pub fn shard_id<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.shard_id = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `config` attribute.
    pub fn config<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.config = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RetrieveTPUEmbeddingAdadeltaParameters` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("RetrieveTPUEmbeddingAdadeltaParameters", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.table_id {
                nd.set_attr_int("table_id", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.table_name {
                nd.set_attr_string("table_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_shards {
                nd.set_attr_int("num_shards", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shard_id {
                nd.set_attr_int("shard_id", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.config {
                nd.set_attr_string("config", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RetrieveTPUEmbeddingAdadeltaParameters' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        scope: &mut crate::Scope,
    ) -> crate::Result<RetrieveTPUEmbeddingAdadeltaParametersInst> {
        let op = scope.new_operation("RetrieveTPUEmbeddingAdadeltaParameters", |builder| {
            if let ::std::option::Option::Some(value) = &self.table_id {
                builder.set_attr_int("table_id", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.table_name {
                builder.set_attr_string("table_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_shards {
                builder.set_attr_int("num_shards", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shard_id {
                builder.set_attr_int("shard_id", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.config {
                builder.set_attr_string("config", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RetrieveTPUEmbeddingAdadeltaParametersInst { op })
    }
}
impl RetrieveTPUEmbeddingAdadeltaParametersInst {
    /// Returns the 'parameters' Output of this 'RetrieveTPUEmbeddingAdadeltaParameters' operation.
    pub fn parameters(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'accumulators' Output of this 'RetrieveTPUEmbeddingAdadeltaParameters' operation.
    pub fn accumulators(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'updates' Output of this 'RetrieveTPUEmbeddingAdadeltaParameters' operation.
    pub fn updates(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
}
impl From<RetrieveTPUEmbeddingAdadeltaParametersInst> for crate::Operation {
    fn from(inst: RetrieveTPUEmbeddingAdadeltaParametersInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RetrieveTPUEmbeddingAdadeltaParameters::new().build(scope)`.
pub fn retrieve_tpuembedding_adadelta_parameters(
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RetrieveTPUEmbeddingAdadeltaParameters::new().build(scope)
}

/// Builder for the `RetrieveTPUEmbeddingAdagradMomentumParameters` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RetrieveTPUEmbeddingAdagradMomentumParameters {
    table_id: ::std::option::Option<i64>,
    table_name: ::std::option::Option<::std::string::String>,
    num_shards: ::std::option::Option<i64>,
    shard_id: ::std::option::Option<i64>,
    config: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RetrieveTPUEmbeddingAdagradMomentumParameters' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RetrieveTPUEmbeddingAdagradMomentumParametersInst {
    /// An instance of a fully built RetrieveTPUEmbeddingAdagradMomentumParameters Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RetrieveTPUEmbeddingAdagradMomentumParameters {
    /// Creates a new `RetrieveTPUEmbeddingAdagradMomentumParameters`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `table_id` attribute.
    pub fn table_id<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.table_id = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `table_name` attribute.
    pub fn table_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.table_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `num_shards` attribute.
    pub fn num_shards<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.num_shards = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shard_id` attribute.
    pub fn shard_id<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.shard_id = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `config` attribute.
    pub fn config<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.config = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RetrieveTPUEmbeddingAdagradMomentumParameters` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("RetrieveTPUEmbeddingAdagradMomentumParameters", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.table_id {
                nd.set_attr_int("table_id", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.table_name {
                nd.set_attr_string("table_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_shards {
                nd.set_attr_int("num_shards", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shard_id {
                nd.set_attr_int("shard_id", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.config {
                nd.set_attr_string("config", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RetrieveTPUEmbeddingAdagradMomentumParameters' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        scope: &mut crate::Scope,
    ) -> crate::Result<RetrieveTPUEmbeddingAdagradMomentumParametersInst> {
        let op =
            scope.new_operation("RetrieveTPUEmbeddingAdagradMomentumParameters", |builder| {
                if let ::std::option::Option::Some(value) = &self.table_id {
                    builder.set_attr_int("table_id", *value)?;
                }
                if let ::std::option::Option::Some(value) = &self.table_name {
                    builder.set_attr_string("table_name", value)?;
                }
                if let ::std::option::Option::Some(value) = &self.num_shards {
                    builder.set_attr_int("num_shards", *value)?;
                }
                if let ::std::option::Option::Some(value) = &self.shard_id {
                    builder.set_attr_int("shard_id", *value)?;
                }
                if let ::std::option::Option::Some(value) = &self.config {
                    builder.set_attr_string("config", value)?;
                }
                ::std::result::Result::Ok(())
            })?;
        Ok(RetrieveTPUEmbeddingAdagradMomentumParametersInst { op })
    }
}
impl RetrieveTPUEmbeddingAdagradMomentumParametersInst {
    /// Returns the 'parameters' Output of this 'RetrieveTPUEmbeddingAdagradMomentumParameters' operation.
    pub fn parameters(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'accumulators' Output of this 'RetrieveTPUEmbeddingAdagradMomentumParameters' operation.
    pub fn accumulators(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'momenta' Output of this 'RetrieveTPUEmbeddingAdagradMomentumParameters' operation.
    pub fn momenta(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
}
impl From<RetrieveTPUEmbeddingAdagradMomentumParametersInst> for crate::Operation {
    fn from(inst: RetrieveTPUEmbeddingAdagradMomentumParametersInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RetrieveTPUEmbeddingAdagradMomentumParameters::new().build(scope)`.
pub fn retrieve_tpuembedding_adagrad_momentum_parameters(
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RetrieveTPUEmbeddingAdagradMomentumParameters::new().build(scope)
}

/// Builder for the `RetrieveTPUEmbeddingAdagradParameters` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RetrieveTPUEmbeddingAdagradParameters {
    table_id: ::std::option::Option<i64>,
    table_name: ::std::option::Option<::std::string::String>,
    num_shards: ::std::option::Option<i64>,
    shard_id: ::std::option::Option<i64>,
    config: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RetrieveTPUEmbeddingAdagradParameters' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RetrieveTPUEmbeddingAdagradParametersInst {
    /// An instance of a fully built RetrieveTPUEmbeddingAdagradParameters Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RetrieveTPUEmbeddingAdagradParameters {
    /// Creates a new `RetrieveTPUEmbeddingAdagradParameters`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `table_id` attribute.
    pub fn table_id<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.table_id = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `table_name` attribute.
    pub fn table_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.table_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `num_shards` attribute.
    pub fn num_shards<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.num_shards = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shard_id` attribute.
    pub fn shard_id<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.shard_id = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `config` attribute.
    pub fn config<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.config = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RetrieveTPUEmbeddingAdagradParameters` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("RetrieveTPUEmbeddingAdagradParameters", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.table_id {
                nd.set_attr_int("table_id", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.table_name {
                nd.set_attr_string("table_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_shards {
                nd.set_attr_int("num_shards", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shard_id {
                nd.set_attr_int("shard_id", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.config {
                nd.set_attr_string("config", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RetrieveTPUEmbeddingAdagradParameters' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        scope: &mut crate::Scope,
    ) -> crate::Result<RetrieveTPUEmbeddingAdagradParametersInst> {
        let op = scope.new_operation("RetrieveTPUEmbeddingAdagradParameters", |builder| {
            if let ::std::option::Option::Some(value) = &self.table_id {
                builder.set_attr_int("table_id", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.table_name {
                builder.set_attr_string("table_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_shards {
                builder.set_attr_int("num_shards", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shard_id {
                builder.set_attr_int("shard_id", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.config {
                builder.set_attr_string("config", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RetrieveTPUEmbeddingAdagradParametersInst { op })
    }
}
impl RetrieveTPUEmbeddingAdagradParametersInst {
    /// Returns the 'parameters' Output of this 'RetrieveTPUEmbeddingAdagradParameters' operation.
    pub fn parameters(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'accumulators' Output of this 'RetrieveTPUEmbeddingAdagradParameters' operation.
    pub fn accumulators(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
}
impl From<RetrieveTPUEmbeddingAdagradParametersInst> for crate::Operation {
    fn from(inst: RetrieveTPUEmbeddingAdagradParametersInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RetrieveTPUEmbeddingAdagradParameters::new().build(scope)`.
pub fn retrieve_tpuembedding_adagrad_parameters(
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RetrieveTPUEmbeddingAdagradParameters::new().build(scope)
}

/// Builder for the `RetrieveTPUEmbeddingCenteredRMSPropParameters` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RetrieveTPUEmbeddingCenteredRMSPropParameters {
    table_id: ::std::option::Option<i64>,
    table_name: ::std::option::Option<::std::string::String>,
    num_shards: ::std::option::Option<i64>,
    shard_id: ::std::option::Option<i64>,
    config: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RetrieveTPUEmbeddingCenteredRMSPropParameters' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RetrieveTPUEmbeddingCenteredRMSPropParametersInst {
    /// An instance of a fully built RetrieveTPUEmbeddingCenteredRMSPropParameters Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RetrieveTPUEmbeddingCenteredRMSPropParameters {
    /// Creates a new `RetrieveTPUEmbeddingCenteredRMSPropParameters`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `table_id` attribute.
    pub fn table_id<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.table_id = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `table_name` attribute.
    pub fn table_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.table_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `num_shards` attribute.
    pub fn num_shards<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.num_shards = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shard_id` attribute.
    pub fn shard_id<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.shard_id = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `config` attribute.
    pub fn config<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.config = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RetrieveTPUEmbeddingCenteredRMSPropParameters` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("RetrieveTPUEmbeddingCenteredRMSPropParameters", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.table_id {
                nd.set_attr_int("table_id", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.table_name {
                nd.set_attr_string("table_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_shards {
                nd.set_attr_int("num_shards", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shard_id {
                nd.set_attr_int("shard_id", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.config {
                nd.set_attr_string("config", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RetrieveTPUEmbeddingCenteredRMSPropParameters' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        scope: &mut crate::Scope,
    ) -> crate::Result<RetrieveTPUEmbeddingCenteredRMSPropParametersInst> {
        let op =
            scope.new_operation("RetrieveTPUEmbeddingCenteredRMSPropParameters", |builder| {
                if let ::std::option::Option::Some(value) = &self.table_id {
                    builder.set_attr_int("table_id", *value)?;
                }
                if let ::std::option::Option::Some(value) = &self.table_name {
                    builder.set_attr_string("table_name", value)?;
                }
                if let ::std::option::Option::Some(value) = &self.num_shards {
                    builder.set_attr_int("num_shards", *value)?;
                }
                if let ::std::option::Option::Some(value) = &self.shard_id {
                    builder.set_attr_int("shard_id", *value)?;
                }
                if let ::std::option::Option::Some(value) = &self.config {
                    builder.set_attr_string("config", value)?;
                }
                ::std::result::Result::Ok(())
            })?;
        Ok(RetrieveTPUEmbeddingCenteredRMSPropParametersInst { op })
    }
}
impl RetrieveTPUEmbeddingCenteredRMSPropParametersInst {
    /// Returns the 'parameters' Output of this 'RetrieveTPUEmbeddingCenteredRMSPropParameters' operation.
    pub fn parameters(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'ms' Output of this 'RetrieveTPUEmbeddingCenteredRMSPropParameters' operation.
    pub fn ms(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'mom' Output of this 'RetrieveTPUEmbeddingCenteredRMSPropParameters' operation.
    pub fn mom(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns the 'mg' Output of this 'RetrieveTPUEmbeddingCenteredRMSPropParameters' operation.
    pub fn mg(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 3,
        }
    }
}
impl From<RetrieveTPUEmbeddingCenteredRMSPropParametersInst> for crate::Operation {
    fn from(inst: RetrieveTPUEmbeddingCenteredRMSPropParametersInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RetrieveTPUEmbeddingCenteredRMSPropParameters::new().build(scope)`.
pub fn retrieve_tpuembedding_centered_rmsprop_parameters(
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RetrieveTPUEmbeddingCenteredRMSPropParameters::new().build(scope)
}

/// Builder for the `RetrieveTPUEmbeddingFTRLParameters` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RetrieveTPUEmbeddingFTRLParameters {
    table_id: ::std::option::Option<i64>,
    table_name: ::std::option::Option<::std::string::String>,
    num_shards: ::std::option::Option<i64>,
    shard_id: ::std::option::Option<i64>,
    config: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RetrieveTPUEmbeddingFTRLParameters' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RetrieveTPUEmbeddingFTRLParametersInst {
    /// An instance of a fully built RetrieveTPUEmbeddingFTRLParameters Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RetrieveTPUEmbeddingFTRLParameters {
    /// Creates a new `RetrieveTPUEmbeddingFTRLParameters`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `table_id` attribute.
    pub fn table_id<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.table_id = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `table_name` attribute.
    pub fn table_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.table_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `num_shards` attribute.
    pub fn num_shards<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.num_shards = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shard_id` attribute.
    pub fn shard_id<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.shard_id = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `config` attribute.
    pub fn config<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.config = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RetrieveTPUEmbeddingFTRLParameters` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("RetrieveTPUEmbeddingFTRLParameters", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.table_id {
                nd.set_attr_int("table_id", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.table_name {
                nd.set_attr_string("table_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_shards {
                nd.set_attr_int("num_shards", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shard_id {
                nd.set_attr_int("shard_id", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.config {
                nd.set_attr_string("config", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RetrieveTPUEmbeddingFTRLParameters' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        scope: &mut crate::Scope,
    ) -> crate::Result<RetrieveTPUEmbeddingFTRLParametersInst> {
        let op = scope.new_operation("RetrieveTPUEmbeddingFTRLParameters", |builder| {
            if let ::std::option::Option::Some(value) = &self.table_id {
                builder.set_attr_int("table_id", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.table_name {
                builder.set_attr_string("table_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_shards {
                builder.set_attr_int("num_shards", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shard_id {
                builder.set_attr_int("shard_id", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.config {
                builder.set_attr_string("config", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RetrieveTPUEmbeddingFTRLParametersInst { op })
    }
}
impl RetrieveTPUEmbeddingFTRLParametersInst {
    /// Returns the 'parameters' Output of this 'RetrieveTPUEmbeddingFTRLParameters' operation.
    pub fn parameters(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'accumulators' Output of this 'RetrieveTPUEmbeddingFTRLParameters' operation.
    pub fn accumulators(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'linears' Output of this 'RetrieveTPUEmbeddingFTRLParameters' operation.
    pub fn linears(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
}
impl From<RetrieveTPUEmbeddingFTRLParametersInst> for crate::Operation {
    fn from(inst: RetrieveTPUEmbeddingFTRLParametersInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RetrieveTPUEmbeddingFTRLParameters::new().build(scope)`.
pub fn retrieve_tpuembedding_ftrlparameters(
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RetrieveTPUEmbeddingFTRLParameters::new().build(scope)
}

/// Builder for the `RetrieveTPUEmbeddingFrequencyEstimatorParameters` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RetrieveTPUEmbeddingFrequencyEstimatorParameters {
    table_id: ::std::option::Option<i64>,
    table_name: ::std::option::Option<::std::string::String>,
    num_shards: ::std::option::Option<i64>,
    shard_id: ::std::option::Option<i64>,
    config: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RetrieveTPUEmbeddingFrequencyEstimatorParameters' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RetrieveTPUEmbeddingFrequencyEstimatorParametersInst {
    /// An instance of a fully built RetrieveTPUEmbeddingFrequencyEstimatorParameters Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RetrieveTPUEmbeddingFrequencyEstimatorParameters {
    /// Creates a new `RetrieveTPUEmbeddingFrequencyEstimatorParameters`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `table_id` attribute.
    pub fn table_id<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.table_id = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `table_name` attribute.
    pub fn table_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.table_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `num_shards` attribute.
    pub fn num_shards<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.num_shards = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shard_id` attribute.
    pub fn shard_id<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.shard_id = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `config` attribute.
    pub fn config<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.config = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RetrieveTPUEmbeddingFrequencyEstimatorParameters` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("RetrieveTPUEmbeddingFrequencyEstimatorParameters", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.table_id {
                nd.set_attr_int("table_id", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.table_name {
                nd.set_attr_string("table_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_shards {
                nd.set_attr_int("num_shards", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shard_id {
                nd.set_attr_int("shard_id", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.config {
                nd.set_attr_string("config", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RetrieveTPUEmbeddingFrequencyEstimatorParameters' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        scope: &mut crate::Scope,
    ) -> crate::Result<RetrieveTPUEmbeddingFrequencyEstimatorParametersInst> {
        let op = scope.new_operation(
            "RetrieveTPUEmbeddingFrequencyEstimatorParameters",
            |builder| {
                if let ::std::option::Option::Some(value) = &self.table_id {
                    builder.set_attr_int("table_id", *value)?;
                }
                if let ::std::option::Option::Some(value) = &self.table_name {
                    builder.set_attr_string("table_name", value)?;
                }
                if let ::std::option::Option::Some(value) = &self.num_shards {
                    builder.set_attr_int("num_shards", *value)?;
                }
                if let ::std::option::Option::Some(value) = &self.shard_id {
                    builder.set_attr_int("shard_id", *value)?;
                }
                if let ::std::option::Option::Some(value) = &self.config {
                    builder.set_attr_string("config", value)?;
                }
                ::std::result::Result::Ok(())
            },
        )?;
        Ok(RetrieveTPUEmbeddingFrequencyEstimatorParametersInst { op })
    }
}
impl RetrieveTPUEmbeddingFrequencyEstimatorParametersInst {
    /// Returns the 'parameters' Output of this 'RetrieveTPUEmbeddingFrequencyEstimatorParameters' operation.
    pub fn parameters(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'last_hit_step' Output of this 'RetrieveTPUEmbeddingFrequencyEstimatorParameters' operation.
    pub fn last_hit_step(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
}
impl From<RetrieveTPUEmbeddingFrequencyEstimatorParametersInst> for crate::Operation {
    fn from(inst: RetrieveTPUEmbeddingFrequencyEstimatorParametersInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RetrieveTPUEmbeddingFrequencyEstimatorParameters::new().build(scope)`.
pub fn retrieve_tpuembedding_frequency_estimator_parameters(
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RetrieveTPUEmbeddingFrequencyEstimatorParameters::new().build(scope)
}

/// Builder for the `RetrieveTPUEmbeddingMDLAdagradLightParameters` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RetrieveTPUEmbeddingMDLAdagradLightParameters {
    table_id: ::std::option::Option<i64>,
    table_name: ::std::option::Option<::std::string::String>,
    num_shards: ::std::option::Option<i64>,
    shard_id: ::std::option::Option<i64>,
    config: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RetrieveTPUEmbeddingMDLAdagradLightParameters' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RetrieveTPUEmbeddingMDLAdagradLightParametersInst {
    /// An instance of a fully built RetrieveTPUEmbeddingMDLAdagradLightParameters Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RetrieveTPUEmbeddingMDLAdagradLightParameters {
    /// Creates a new `RetrieveTPUEmbeddingMDLAdagradLightParameters`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `table_id` attribute.
    pub fn table_id<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.table_id = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `table_name` attribute.
    pub fn table_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.table_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `num_shards` attribute.
    pub fn num_shards<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.num_shards = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shard_id` attribute.
    pub fn shard_id<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.shard_id = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `config` attribute.
    pub fn config<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.config = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RetrieveTPUEmbeddingMDLAdagradLightParameters` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("RetrieveTPUEmbeddingMDLAdagradLightParameters", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.table_id {
                nd.set_attr_int("table_id", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.table_name {
                nd.set_attr_string("table_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_shards {
                nd.set_attr_int("num_shards", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shard_id {
                nd.set_attr_int("shard_id", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.config {
                nd.set_attr_string("config", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RetrieveTPUEmbeddingMDLAdagradLightParameters' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        scope: &mut crate::Scope,
    ) -> crate::Result<RetrieveTPUEmbeddingMDLAdagradLightParametersInst> {
        let op =
            scope.new_operation("RetrieveTPUEmbeddingMDLAdagradLightParameters", |builder| {
                if let ::std::option::Option::Some(value) = &self.table_id {
                    builder.set_attr_int("table_id", *value)?;
                }
                if let ::std::option::Option::Some(value) = &self.table_name {
                    builder.set_attr_string("table_name", value)?;
                }
                if let ::std::option::Option::Some(value) = &self.num_shards {
                    builder.set_attr_int("num_shards", *value)?;
                }
                if let ::std::option::Option::Some(value) = &self.shard_id {
                    builder.set_attr_int("shard_id", *value)?;
                }
                if let ::std::option::Option::Some(value) = &self.config {
                    builder.set_attr_string("config", value)?;
                }
                ::std::result::Result::Ok(())
            })?;
        Ok(RetrieveTPUEmbeddingMDLAdagradLightParametersInst { op })
    }
}
impl RetrieveTPUEmbeddingMDLAdagradLightParametersInst {
    /// Returns the 'parameters' Output of this 'RetrieveTPUEmbeddingMDLAdagradLightParameters' operation.
    pub fn parameters(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'accumulators' Output of this 'RetrieveTPUEmbeddingMDLAdagradLightParameters' operation.
    pub fn accumulators(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'weights' Output of this 'RetrieveTPUEmbeddingMDLAdagradLightParameters' operation.
    pub fn weights(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns the 'benefits' Output of this 'RetrieveTPUEmbeddingMDLAdagradLightParameters' operation.
    pub fn benefits(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 3,
        }
    }
}
impl From<RetrieveTPUEmbeddingMDLAdagradLightParametersInst> for crate::Operation {
    fn from(inst: RetrieveTPUEmbeddingMDLAdagradLightParametersInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RetrieveTPUEmbeddingMDLAdagradLightParameters::new().build(scope)`.
pub fn retrieve_tpuembedding_mdladagrad_light_parameters(
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RetrieveTPUEmbeddingMDLAdagradLightParameters::new().build(scope)
}

/// Builder for the `RetrieveTPUEmbeddingMomentumParameters` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RetrieveTPUEmbeddingMomentumParameters {
    table_id: ::std::option::Option<i64>,
    table_name: ::std::option::Option<::std::string::String>,
    num_shards: ::std::option::Option<i64>,
    shard_id: ::std::option::Option<i64>,
    config: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RetrieveTPUEmbeddingMomentumParameters' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RetrieveTPUEmbeddingMomentumParametersInst {
    /// An instance of a fully built RetrieveTPUEmbeddingMomentumParameters Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RetrieveTPUEmbeddingMomentumParameters {
    /// Creates a new `RetrieveTPUEmbeddingMomentumParameters`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `table_id` attribute.
    pub fn table_id<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.table_id = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `table_name` attribute.
    pub fn table_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.table_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `num_shards` attribute.
    pub fn num_shards<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.num_shards = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shard_id` attribute.
    pub fn shard_id<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.shard_id = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `config` attribute.
    pub fn config<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.config = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RetrieveTPUEmbeddingMomentumParameters` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("RetrieveTPUEmbeddingMomentumParameters", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.table_id {
                nd.set_attr_int("table_id", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.table_name {
                nd.set_attr_string("table_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_shards {
                nd.set_attr_int("num_shards", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shard_id {
                nd.set_attr_int("shard_id", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.config {
                nd.set_attr_string("config", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RetrieveTPUEmbeddingMomentumParameters' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        scope: &mut crate::Scope,
    ) -> crate::Result<RetrieveTPUEmbeddingMomentumParametersInst> {
        let op = scope.new_operation("RetrieveTPUEmbeddingMomentumParameters", |builder| {
            if let ::std::option::Option::Some(value) = &self.table_id {
                builder.set_attr_int("table_id", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.table_name {
                builder.set_attr_string("table_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_shards {
                builder.set_attr_int("num_shards", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shard_id {
                builder.set_attr_int("shard_id", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.config {
                builder.set_attr_string("config", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RetrieveTPUEmbeddingMomentumParametersInst { op })
    }
}
impl RetrieveTPUEmbeddingMomentumParametersInst {
    /// Returns the 'parameters' Output of this 'RetrieveTPUEmbeddingMomentumParameters' operation.
    pub fn parameters(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'momenta' Output of this 'RetrieveTPUEmbeddingMomentumParameters' operation.
    pub fn momenta(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
}
impl From<RetrieveTPUEmbeddingMomentumParametersInst> for crate::Operation {
    fn from(inst: RetrieveTPUEmbeddingMomentumParametersInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RetrieveTPUEmbeddingMomentumParameters::new().build(scope)`.
pub fn retrieve_tpuembedding_momentum_parameters(
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RetrieveTPUEmbeddingMomentumParameters::new().build(scope)
}

/// Builder for the `RetrieveTPUEmbeddingProximalAdagradParameters` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RetrieveTPUEmbeddingProximalAdagradParameters {
    table_id: ::std::option::Option<i64>,
    table_name: ::std::option::Option<::std::string::String>,
    num_shards: ::std::option::Option<i64>,
    shard_id: ::std::option::Option<i64>,
    config: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RetrieveTPUEmbeddingProximalAdagradParameters' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RetrieveTPUEmbeddingProximalAdagradParametersInst {
    /// An instance of a fully built RetrieveTPUEmbeddingProximalAdagradParameters Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RetrieveTPUEmbeddingProximalAdagradParameters {
    /// Creates a new `RetrieveTPUEmbeddingProximalAdagradParameters`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `table_id` attribute.
    pub fn table_id<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.table_id = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `table_name` attribute.
    pub fn table_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.table_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `num_shards` attribute.
    pub fn num_shards<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.num_shards = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shard_id` attribute.
    pub fn shard_id<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.shard_id = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `config` attribute.
    pub fn config<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.config = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RetrieveTPUEmbeddingProximalAdagradParameters` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("RetrieveTPUEmbeddingProximalAdagradParameters", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.table_id {
                nd.set_attr_int("table_id", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.table_name {
                nd.set_attr_string("table_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_shards {
                nd.set_attr_int("num_shards", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shard_id {
                nd.set_attr_int("shard_id", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.config {
                nd.set_attr_string("config", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RetrieveTPUEmbeddingProximalAdagradParameters' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        scope: &mut crate::Scope,
    ) -> crate::Result<RetrieveTPUEmbeddingProximalAdagradParametersInst> {
        let op =
            scope.new_operation("RetrieveTPUEmbeddingProximalAdagradParameters", |builder| {
                if let ::std::option::Option::Some(value) = &self.table_id {
                    builder.set_attr_int("table_id", *value)?;
                }
                if let ::std::option::Option::Some(value) = &self.table_name {
                    builder.set_attr_string("table_name", value)?;
                }
                if let ::std::option::Option::Some(value) = &self.num_shards {
                    builder.set_attr_int("num_shards", *value)?;
                }
                if let ::std::option::Option::Some(value) = &self.shard_id {
                    builder.set_attr_int("shard_id", *value)?;
                }
                if let ::std::option::Option::Some(value) = &self.config {
                    builder.set_attr_string("config", value)?;
                }
                ::std::result::Result::Ok(())
            })?;
        Ok(RetrieveTPUEmbeddingProximalAdagradParametersInst { op })
    }
}
impl RetrieveTPUEmbeddingProximalAdagradParametersInst {
    /// Returns the 'parameters' Output of this 'RetrieveTPUEmbeddingProximalAdagradParameters' operation.
    pub fn parameters(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'accumulators' Output of this 'RetrieveTPUEmbeddingProximalAdagradParameters' operation.
    pub fn accumulators(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
}
impl From<RetrieveTPUEmbeddingProximalAdagradParametersInst> for crate::Operation {
    fn from(inst: RetrieveTPUEmbeddingProximalAdagradParametersInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RetrieveTPUEmbeddingProximalAdagradParameters::new().build(scope)`.
pub fn retrieve_tpuembedding_proximal_adagrad_parameters(
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RetrieveTPUEmbeddingProximalAdagradParameters::new().build(scope)
}

/// Builder for the `RetrieveTPUEmbeddingProximalYogiParameters` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RetrieveTPUEmbeddingProximalYogiParameters {
    table_id: ::std::option::Option<i64>,
    table_name: ::std::option::Option<::std::string::String>,
    num_shards: ::std::option::Option<i64>,
    shard_id: ::std::option::Option<i64>,
    config: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RetrieveTPUEmbeddingProximalYogiParameters' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RetrieveTPUEmbeddingProximalYogiParametersInst {
    /// An instance of a fully built RetrieveTPUEmbeddingProximalYogiParameters Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RetrieveTPUEmbeddingProximalYogiParameters {
    /// Creates a new `RetrieveTPUEmbeddingProximalYogiParameters`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `table_id` attribute.
    pub fn table_id<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.table_id = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `table_name` attribute.
    pub fn table_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.table_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `num_shards` attribute.
    pub fn num_shards<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.num_shards = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shard_id` attribute.
    pub fn shard_id<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.shard_id = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `config` attribute.
    pub fn config<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.config = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RetrieveTPUEmbeddingProximalYogiParameters` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("RetrieveTPUEmbeddingProximalYogiParameters", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.table_id {
                nd.set_attr_int("table_id", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.table_name {
                nd.set_attr_string("table_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_shards {
                nd.set_attr_int("num_shards", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shard_id {
                nd.set_attr_int("shard_id", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.config {
                nd.set_attr_string("config", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RetrieveTPUEmbeddingProximalYogiParameters' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        scope: &mut crate::Scope,
    ) -> crate::Result<RetrieveTPUEmbeddingProximalYogiParametersInst> {
        let op = scope.new_operation("RetrieveTPUEmbeddingProximalYogiParameters", |builder| {
            if let ::std::option::Option::Some(value) = &self.table_id {
                builder.set_attr_int("table_id", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.table_name {
                builder.set_attr_string("table_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_shards {
                builder.set_attr_int("num_shards", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shard_id {
                builder.set_attr_int("shard_id", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.config {
                builder.set_attr_string("config", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RetrieveTPUEmbeddingProximalYogiParametersInst { op })
    }
}
impl RetrieveTPUEmbeddingProximalYogiParametersInst {
    /// Returns the 'parameters' Output of this 'RetrieveTPUEmbeddingProximalYogiParameters' operation.
    pub fn parameters(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'v' Output of this 'RetrieveTPUEmbeddingProximalYogiParameters' operation.
    pub fn v(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'm' Output of this 'RetrieveTPUEmbeddingProximalYogiParameters' operation.
    pub fn m(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
}
impl From<RetrieveTPUEmbeddingProximalYogiParametersInst> for crate::Operation {
    fn from(inst: RetrieveTPUEmbeddingProximalYogiParametersInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RetrieveTPUEmbeddingProximalYogiParameters::new().build(scope)`.
pub fn retrieve_tpuembedding_proximal_yogi_parameters(
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RetrieveTPUEmbeddingProximalYogiParameters::new().build(scope)
}

/// Builder for the `RetrieveTPUEmbeddingRMSPropParameters` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RetrieveTPUEmbeddingRMSPropParameters {
    table_id: ::std::option::Option<i64>,
    table_name: ::std::option::Option<::std::string::String>,
    num_shards: ::std::option::Option<i64>,
    shard_id: ::std::option::Option<i64>,
    config: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RetrieveTPUEmbeddingRMSPropParameters' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RetrieveTPUEmbeddingRMSPropParametersInst {
    /// An instance of a fully built RetrieveTPUEmbeddingRMSPropParameters Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RetrieveTPUEmbeddingRMSPropParameters {
    /// Creates a new `RetrieveTPUEmbeddingRMSPropParameters`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `table_id` attribute.
    pub fn table_id<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.table_id = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `table_name` attribute.
    pub fn table_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.table_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `num_shards` attribute.
    pub fn num_shards<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.num_shards = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shard_id` attribute.
    pub fn shard_id<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.shard_id = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `config` attribute.
    pub fn config<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.config = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RetrieveTPUEmbeddingRMSPropParameters` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("RetrieveTPUEmbeddingRMSPropParameters", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.table_id {
                nd.set_attr_int("table_id", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.table_name {
                nd.set_attr_string("table_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_shards {
                nd.set_attr_int("num_shards", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shard_id {
                nd.set_attr_int("shard_id", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.config {
                nd.set_attr_string("config", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RetrieveTPUEmbeddingRMSPropParameters' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        scope: &mut crate::Scope,
    ) -> crate::Result<RetrieveTPUEmbeddingRMSPropParametersInst> {
        let op = scope.new_operation("RetrieveTPUEmbeddingRMSPropParameters", |builder| {
            if let ::std::option::Option::Some(value) = &self.table_id {
                builder.set_attr_int("table_id", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.table_name {
                builder.set_attr_string("table_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_shards {
                builder.set_attr_int("num_shards", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shard_id {
                builder.set_attr_int("shard_id", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.config {
                builder.set_attr_string("config", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RetrieveTPUEmbeddingRMSPropParametersInst { op })
    }
}
impl RetrieveTPUEmbeddingRMSPropParametersInst {
    /// Returns the 'parameters' Output of this 'RetrieveTPUEmbeddingRMSPropParameters' operation.
    pub fn parameters(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'ms' Output of this 'RetrieveTPUEmbeddingRMSPropParameters' operation.
    pub fn ms(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'mom' Output of this 'RetrieveTPUEmbeddingRMSPropParameters' operation.
    pub fn mom(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
}
impl From<RetrieveTPUEmbeddingRMSPropParametersInst> for crate::Operation {
    fn from(inst: RetrieveTPUEmbeddingRMSPropParametersInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RetrieveTPUEmbeddingRMSPropParameters::new().build(scope)`.
pub fn retrieve_tpuembedding_rmsprop_parameters(
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RetrieveTPUEmbeddingRMSPropParameters::new().build(scope)
}

/// Builder for the `RetrieveTPUEmbeddingStochasticGradientDescentParameters` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RetrieveTPUEmbeddingStochasticGradientDescentParameters {
    table_id: ::std::option::Option<i64>,
    table_name: ::std::option::Option<::std::string::String>,
    num_shards: ::std::option::Option<i64>,
    shard_id: ::std::option::Option<i64>,
    config: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RetrieveTPUEmbeddingStochasticGradientDescentParameters' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RetrieveTPUEmbeddingStochasticGradientDescentParametersInst {
    /// An instance of a fully built RetrieveTPUEmbeddingStochasticGradientDescentParameters Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RetrieveTPUEmbeddingStochasticGradientDescentParameters {
    /// Creates a new `RetrieveTPUEmbeddingStochasticGradientDescentParameters`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `table_id` attribute.
    pub fn table_id<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.table_id = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `table_name` attribute.
    pub fn table_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.table_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `num_shards` attribute.
    pub fn num_shards<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.num_shards = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shard_id` attribute.
    pub fn shard_id<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.shard_id = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `config` attribute.
    pub fn config<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.config = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RetrieveTPUEmbeddingStochasticGradientDescentParameters` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation(
            "RetrieveTPUEmbeddingStochasticGradientDescentParameters",
            |nd| {
                for op in &self.control_inputs {
                    nd.add_control_input(op);
                }
                if let ::std::option::Option::Some(value) = &self.table_id {
                    nd.set_attr_int("table_id", *value)?;
                }
                if let ::std::option::Option::Some(value) = &self.table_name {
                    nd.set_attr_string("table_name", value)?;
                }
                if let ::std::option::Option::Some(value) = &self.num_shards {
                    nd.set_attr_int("num_shards", *value)?;
                }
                if let ::std::option::Option::Some(value) = &self.shard_id {
                    nd.set_attr_int("shard_id", *value)?;
                }
                if let ::std::option::Option::Some(value) = &self.config {
                    nd.set_attr_string("config", value)?;
                }
                ::std::result::Result::Ok(())
            },
        )
    }

    /// Builds a new instance of 'RetrieveTPUEmbeddingStochasticGradientDescentParameters' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        scope: &mut crate::Scope,
    ) -> crate::Result<RetrieveTPUEmbeddingStochasticGradientDescentParametersInst> {
        let op = scope.new_operation(
            "RetrieveTPUEmbeddingStochasticGradientDescentParameters",
            |builder| {
                if let ::std::option::Option::Some(value) = &self.table_id {
                    builder.set_attr_int("table_id", *value)?;
                }
                if let ::std::option::Option::Some(value) = &self.table_name {
                    builder.set_attr_string("table_name", value)?;
                }
                if let ::std::option::Option::Some(value) = &self.num_shards {
                    builder.set_attr_int("num_shards", *value)?;
                }
                if let ::std::option::Option::Some(value) = &self.shard_id {
                    builder.set_attr_int("shard_id", *value)?;
                }
                if let ::std::option::Option::Some(value) = &self.config {
                    builder.set_attr_string("config", value)?;
                }
                ::std::result::Result::Ok(())
            },
        )?;
        Ok(RetrieveTPUEmbeddingStochasticGradientDescentParametersInst { op })
    }
}
impl RetrieveTPUEmbeddingStochasticGradientDescentParametersInst {
    /// Returns the 'parameters' Output of this 'RetrieveTPUEmbeddingStochasticGradientDescentParameters' operation.
    pub fn parameters(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
}
impl From<RetrieveTPUEmbeddingStochasticGradientDescentParametersInst> for crate::Operation {
    fn from(inst: RetrieveTPUEmbeddingStochasticGradientDescentParametersInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RetrieveTPUEmbeddingStochasticGradientDescentParameters::new().build(scope)`.
pub fn retrieve_tpuembedding_stochastic_gradient_descent_parameters(
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RetrieveTPUEmbeddingStochasticGradientDescentParameters::new().build(scope)
}

/// Builder for the `Reverse` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Reverse {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Reverse' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ReverseInst {
    /// An instance of a fully built Reverse Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Reverse {
    /// Creates a new `Reverse`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Reverse` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        tensor: O0,
        dims: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(tensor.into(), dims.into(), scope)
    }
    fn build_impl(
        &self,
        tensor: crate::Output,
        dims: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Reverse", |nd| {
            nd.add_input(tensor);
            nd.add_input(dims);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Reverse' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        tensor: crate::Output,
        dims: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ReverseInst> {
        let op = scope.new_operation("Reverse", |builder| {
            builder.add_input(tensor);
            builder.add_input(dims);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ReverseInst { op })
    }
}
impl ReverseInst {
    /// Returns the 'output' Output of this 'Reverse' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'tensor' Input of this 'Reverse' operation.
    pub fn tensor(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'dims' Input of this 'Reverse' operation.
    pub fn dims(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<ReverseInst> for crate::Operation {
    fn from(inst: ReverseInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Reverse::new().build(tensor, dims, scope)`.
pub fn reverse<O0: ::std::convert::Into<crate::Output>, O1: ::std::convert::Into<crate::Output>>(
    tensor: O0,
    dims: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Reverse::new().build(tensor, dims, scope)
}

/// Builder for the `ReverseSequence` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ReverseSequence {
    seq_dim: ::std::option::Option<i64>,
    batch_dim: ::std::option::Option<i64>,
    T: ::std::option::Option<crate::DataType>,
    Tlen: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ReverseSequence' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ReverseSequenceInst {
    /// An instance of a fully built ReverseSequence Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ReverseSequence {
    /// Creates a new `ReverseSequence`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `seq_dim` attribute.
    pub fn seq_dim<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.seq_dim = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `batch_dim` attribute.
    pub fn batch_dim<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.batch_dim = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tlen` attribute.
    pub fn Tlen<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Tlen = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ReverseSequence` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        seq_lengths: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), seq_lengths.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        seq_lengths: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ReverseSequence", |nd| {
            nd.add_input(input);
            nd.add_input(seq_lengths);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.seq_dim {
                nd.set_attr_int("seq_dim", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.batch_dim {
                nd.set_attr_int("batch_dim", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tlen {
                nd.set_attr_type("Tlen", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ReverseSequence' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        seq_lengths: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ReverseSequenceInst> {
        let op = scope.new_operation("ReverseSequence", |builder| {
            builder.add_input(input);
            builder.add_input(seq_lengths);
            if let ::std::option::Option::Some(value) = &self.seq_dim {
                builder.set_attr_int("seq_dim", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.batch_dim {
                builder.set_attr_int("batch_dim", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tlen {
                builder.set_attr_type("Tlen", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ReverseSequenceInst { op })
    }
}
impl ReverseSequenceInst {
    /// Returns the 'output' Output of this 'ReverseSequence' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'ReverseSequence' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'seq_lengths' Input of this 'ReverseSequence' operation.
    pub fn seq_lengths(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<ReverseSequenceInst> for crate::Operation {
    fn from(inst: ReverseSequenceInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ReverseSequence::new().build(input, seq_lengths, scope)`.
pub fn reverse_sequence<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    input: O0,
    seq_lengths: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ReverseSequence::new().build(input, seq_lengths, scope)
}

/// Builder for the `ReverseV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ReverseV2 {
    Tidx: ::std::option::Option<crate::DataType>,
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ReverseV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ReverseV2Inst {
    /// An instance of a fully built ReverseV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ReverseV2 {
    /// Creates a new `ReverseV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `Tidx` attribute.
    pub fn Tidx<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Tidx = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ReverseV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        tensor: O0,
        axis: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(tensor.into(), axis.into(), scope)
    }
    fn build_impl(
        &self,
        tensor: crate::Output,
        axis: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ReverseV2", |nd| {
            nd.add_input(tensor);
            nd.add_input(axis);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.Tidx {
                nd.set_attr_type("Tidx", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ReverseV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        tensor: crate::Output,
        axis: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ReverseV2Inst> {
        let op = scope.new_operation("ReverseV2", |builder| {
            builder.add_input(tensor);
            builder.add_input(axis);
            if let ::std::option::Option::Some(value) = &self.Tidx {
                builder.set_attr_type("Tidx", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ReverseV2Inst { op })
    }
}
impl ReverseV2Inst {
    /// Returns the 'output' Output of this 'ReverseV2' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'tensor' Input of this 'ReverseV2' operation.
    pub fn tensor(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'axis' Input of this 'ReverseV2' operation.
    pub fn axis(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<ReverseV2Inst> for crate::Operation {
    fn from(inst: ReverseV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ReverseV2::new().build(tensor, axis, scope)`.
pub fn reverse_v2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    tensor: O0,
    axis: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ReverseV2::new().build(tensor, axis, scope)
}

/// Builder for the `RewriteDataset` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RewriteDataset {
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RewriteDataset' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RewriteDatasetInst {
    /// An instance of a fully built RewriteDataset Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RewriteDataset {
    /// Creates a new `RewriteDataset`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RewriteDataset` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input_dataset: O0,
        rewrite_name: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input_dataset.into(), rewrite_name.into(), scope)
    }
    fn build_impl(
        &self,
        input_dataset: crate::Output,
        rewrite_name: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("RewriteDataset", |nd| {
            nd.add_input(input_dataset);
            nd.add_input(rewrite_name);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RewriteDataset' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_dataset: crate::Output,
        rewrite_name: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<RewriteDatasetInst> {
        let op = scope.new_operation("RewriteDataset", |builder| {
            builder.add_input(input_dataset);
            builder.add_input(rewrite_name);
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RewriteDatasetInst { op })
    }
}
impl RewriteDatasetInst {
    /// Returns the 'handle' Output of this 'RewriteDataset' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_dataset' Input of this 'RewriteDataset' operation.
    pub fn input_dataset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'rewrite_name' Input of this 'RewriteDataset' operation.
    pub fn rewrite_name(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<RewriteDatasetInst> for crate::Operation {
    fn from(inst: RewriteDatasetInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RewriteDataset::new().build(input_dataset, rewrite_name, scope)`.
pub fn rewrite_dataset<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    input_dataset: O0,
    rewrite_name: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RewriteDataset::new().build(input_dataset, rewrite_name, scope)
}

/// Builder for the `RightShift` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RightShift {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RightShift' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RightShiftInst {
    /// An instance of a fully built RightShift Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RightShift {
    /// Creates a new `RightShift`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RightShift` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        x: O0,
        y: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), y.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        y: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("RightShift", |nd| {
            nd.add_input(x);
            nd.add_input(y);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RightShift' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        y: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<RightShiftInst> {
        let op = scope.new_operation("RightShift", |builder| {
            builder.add_input(x);
            builder.add_input(y);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RightShiftInst { op })
    }
}
impl RightShiftInst {
    /// Returns the 'z' Output of this 'RightShift' operation.
    pub fn z(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'RightShift' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'y' Input of this 'RightShift' operation.
    pub fn y(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<RightShiftInst> for crate::Operation {
    fn from(inst: RightShiftInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RightShift::new().build(x, y, scope)`.
pub fn right_shift<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    x: O0,
    y: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RightShift::new().build(x, y, scope)
}

/// Builder for the `Rint` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Rint {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Rint' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RintInst {
    /// An instance of a fully built Rint Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Rint {
    /// Creates a new `Rint`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Rint` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        x: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Rint", |nd| {
            nd.add_input(x);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Rint' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<RintInst> {
        let op = scope.new_operation("Rint", |builder| {
            builder.add_input(x);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RintInst { op })
    }
}
impl RintInst {
    /// Returns the 'y' Output of this 'Rint' operation.
    pub fn y(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'Rint' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<RintInst> for crate::Operation {
    fn from(inst: RintInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Rint::new().build(x, scope)`.
pub fn rint<O0: ::std::convert::Into<crate::Output>>(
    x: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Rint::new().build(x, scope)
}

/// Builder for the `RiscAbs` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RiscAbs {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RiscAbs' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RiscAbsInst {
    /// An instance of a fully built RiscAbs Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RiscAbs {
    /// Creates a new `RiscAbs`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RiscAbs` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        x: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("RiscAbs", |nd| {
            nd.add_input(x);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RiscAbs' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<RiscAbsInst> {
        let op = scope.new_operation("RiscAbs", |builder| {
            builder.add_input(x);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RiscAbsInst { op })
    }
}
impl RiscAbsInst {
    /// Returns the 'y' Output of this 'RiscAbs' operation.
    pub fn y(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'RiscAbs' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<RiscAbsInst> for crate::Operation {
    fn from(inst: RiscAbsInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RiscAbs::new().build(x, scope)`.
pub fn risc_abs<O0: ::std::convert::Into<crate::Output>>(
    x: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RiscAbs::new().build(x, scope)
}

/// Builder for the `RiscAdd` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RiscAdd {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RiscAdd' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RiscAddInst {
    /// An instance of a fully built RiscAdd Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RiscAdd {
    /// Creates a new `RiscAdd`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RiscAdd` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        x: O0,
        y: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), y.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        y: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("RiscAdd", |nd| {
            nd.add_input(x);
            nd.add_input(y);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RiscAdd' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        y: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<RiscAddInst> {
        let op = scope.new_operation("RiscAdd", |builder| {
            builder.add_input(x);
            builder.add_input(y);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RiscAddInst { op })
    }
}
impl RiscAddInst {
    /// Returns the 'z' Output of this 'RiscAdd' operation.
    pub fn z(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'RiscAdd' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'y' Input of this 'RiscAdd' operation.
    pub fn y(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<RiscAddInst> for crate::Operation {
    fn from(inst: RiscAddInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RiscAdd::new().build(x, y, scope)`.
pub fn risc_add<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    x: O0,
    y: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RiscAdd::new().build(x, y, scope)
}

/// Builder for the `RiscBinaryArithmetic` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RiscBinaryArithmetic {
    op_type: ::std::option::Option<::std::string::String>,
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RiscBinaryArithmetic' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RiscBinaryArithmeticInst {
    /// An instance of a fully built RiscBinaryArithmetic Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RiscBinaryArithmetic {
    /// Creates a new `RiscBinaryArithmetic`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `op_type` attribute.
    pub fn op_type<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.op_type = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RiscBinaryArithmetic` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        x: O0,
        y: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), y.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        y: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("RiscBinaryArithmetic", |nd| {
            nd.add_input(x);
            nd.add_input(y);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.op_type {
                nd.set_attr_string("op_type", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RiscBinaryArithmetic' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        y: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<RiscBinaryArithmeticInst> {
        let op = scope.new_operation("RiscBinaryArithmetic", |builder| {
            builder.add_input(x);
            builder.add_input(y);
            if let ::std::option::Option::Some(value) = &self.op_type {
                builder.set_attr_string("op_type", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RiscBinaryArithmeticInst { op })
    }
}
impl RiscBinaryArithmeticInst {
    /// Returns the 'z' Output of this 'RiscBinaryArithmetic' operation.
    pub fn z(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'RiscBinaryArithmetic' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'y' Input of this 'RiscBinaryArithmetic' operation.
    pub fn y(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<RiscBinaryArithmeticInst> for crate::Operation {
    fn from(inst: RiscBinaryArithmeticInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RiscBinaryArithmetic::new().build(x, y, scope)`.
pub fn risc_binary_arithmetic<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    x: O0,
    y: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RiscBinaryArithmetic::new().build(x, y, scope)
}

/// Builder for the `RiscBinaryComparison` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RiscBinaryComparison {
    op_type: ::std::option::Option<::std::string::String>,
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RiscBinaryComparison' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RiscBinaryComparisonInst {
    /// An instance of a fully built RiscBinaryComparison Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RiscBinaryComparison {
    /// Creates a new `RiscBinaryComparison`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `op_type` attribute.
    pub fn op_type<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.op_type = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RiscBinaryComparison` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        x: O0,
        y: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), y.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        y: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("RiscBinaryComparison", |nd| {
            nd.add_input(x);
            nd.add_input(y);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.op_type {
                nd.set_attr_string("op_type", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RiscBinaryComparison' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        y: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<RiscBinaryComparisonInst> {
        let op = scope.new_operation("RiscBinaryComparison", |builder| {
            builder.add_input(x);
            builder.add_input(y);
            if let ::std::option::Option::Some(value) = &self.op_type {
                builder.set_attr_string("op_type", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RiscBinaryComparisonInst { op })
    }
}
impl RiscBinaryComparisonInst {
    /// Returns the 'z' Output of this 'RiscBinaryComparison' operation.
    pub fn z(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'RiscBinaryComparison' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'y' Input of this 'RiscBinaryComparison' operation.
    pub fn y(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<RiscBinaryComparisonInst> for crate::Operation {
    fn from(inst: RiscBinaryComparisonInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RiscBinaryComparison::new().build(x, y, scope)`.
pub fn risc_binary_comparison<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    x: O0,
    y: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RiscBinaryComparison::new().build(x, y, scope)
}

/// Builder for the `RiscBitcast` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RiscBitcast {
    SrcT: ::std::option::Option<crate::DataType>,
    DstT: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RiscBitcast' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RiscBitcastInst {
    /// An instance of a fully built RiscBitcast Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RiscBitcast {
    /// Creates a new `RiscBitcast`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `SrcT` attribute.
    pub fn SrcT<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.SrcT = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `DstT` attribute.
    pub fn DstT<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.DstT = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RiscBitcast` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        x: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("RiscBitcast", |nd| {
            nd.add_input(x);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.SrcT {
                nd.set_attr_type("SrcT", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.DstT {
                nd.set_attr_type("DstT", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RiscBitcast' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<RiscBitcastInst> {
        let op = scope.new_operation("RiscBitcast", |builder| {
            builder.add_input(x);
            if let ::std::option::Option::Some(value) = &self.SrcT {
                builder.set_attr_type("SrcT", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.DstT {
                builder.set_attr_type("DstT", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RiscBitcastInst { op })
    }
}
impl RiscBitcastInst {
    /// Returns the 'y' Output of this 'RiscBitcast' operation.
    pub fn y(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'RiscBitcast' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<RiscBitcastInst> for crate::Operation {
    fn from(inst: RiscBitcastInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RiscBitcast::new().build(x, scope)`.
pub fn risc_bitcast<O0: ::std::convert::Into<crate::Output>>(
    x: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RiscBitcast::new().build(x, scope)
}

/// Builder for the `RiscBroadcast` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RiscBroadcast {
    T: ::std::option::Option<crate::DataType>,
    Tidx: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RiscBroadcast' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RiscBroadcastInst {
    /// An instance of a fully built RiscBroadcast Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RiscBroadcast {
    /// Creates a new `RiscBroadcast`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tidx` attribute.
    pub fn Tidx<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Tidx = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RiscBroadcast` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        shape: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), shape.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        shape: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("RiscBroadcast", |nd| {
            nd.add_input(input);
            nd.add_input(shape);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tidx {
                nd.set_attr_type("Tidx", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RiscBroadcast' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        shape: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<RiscBroadcastInst> {
        let op = scope.new_operation("RiscBroadcast", |builder| {
            builder.add_input(input);
            builder.add_input(shape);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tidx {
                builder.set_attr_type("Tidx", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RiscBroadcastInst { op })
    }
}
impl RiscBroadcastInst {
    /// Returns the 'output' Output of this 'RiscBroadcast' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'RiscBroadcast' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'shape' Input of this 'RiscBroadcast' operation.
    pub fn shape(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<RiscBroadcastInst> for crate::Operation {
    fn from(inst: RiscBroadcastInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RiscBroadcast::new().build(input, shape, scope)`.
pub fn risc_broadcast<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    input: O0,
    shape: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RiscBroadcast::new().build(input, shape, scope)
}

/// Builder for the `RiscCast` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RiscCast {
    SrcT: ::std::option::Option<crate::DataType>,
    DstT: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RiscCast' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RiscCastInst {
    /// An instance of a fully built RiscCast Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RiscCast {
    /// Creates a new `RiscCast`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `SrcT` attribute.
    pub fn SrcT<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.SrcT = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `DstT` attribute.
    pub fn DstT<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.DstT = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RiscCast` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        x: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("RiscCast", |nd| {
            nd.add_input(x);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.SrcT {
                nd.set_attr_type("SrcT", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.DstT {
                nd.set_attr_type("DstT", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RiscCast' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<RiscCastInst> {
        let op = scope.new_operation("RiscCast", |builder| {
            builder.add_input(x);
            if let ::std::option::Option::Some(value) = &self.SrcT {
                builder.set_attr_type("SrcT", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.DstT {
                builder.set_attr_type("DstT", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RiscCastInst { op })
    }
}
impl RiscCastInst {
    /// Returns the 'y' Output of this 'RiscCast' operation.
    pub fn y(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'RiscCast' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<RiscCastInst> for crate::Operation {
    fn from(inst: RiscCastInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RiscCast::new().build(x, scope)`.
pub fn risc_cast<O0: ::std::convert::Into<crate::Output>>(
    x: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RiscCast::new().build(x, scope)
}

/// Builder for the `RiscCeil` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RiscCeil {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RiscCeil' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RiscCeilInst {
    /// An instance of a fully built RiscCeil Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RiscCeil {
    /// Creates a new `RiscCeil`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RiscCeil` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        x: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("RiscCeil", |nd| {
            nd.add_input(x);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RiscCeil' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<RiscCeilInst> {
        let op = scope.new_operation("RiscCeil", |builder| {
            builder.add_input(x);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RiscCeilInst { op })
    }
}
impl RiscCeilInst {
    /// Returns the 'y' Output of this 'RiscCeil' operation.
    pub fn y(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'RiscCeil' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<RiscCeilInst> for crate::Operation {
    fn from(inst: RiscCeilInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RiscCeil::new().build(x, scope)`.
pub fn risc_ceil<O0: ::std::convert::Into<crate::Output>>(
    x: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RiscCeil::new().build(x, scope)
}

/// Builder for the `RiscCholesky` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RiscCholesky {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RiscCholesky' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RiscCholeskyInst {
    /// An instance of a fully built RiscCholesky Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RiscCholesky {
    /// Creates a new `RiscCholesky`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RiscCholesky` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("RiscCholesky", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RiscCholesky' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<RiscCholeskyInst> {
        let op = scope.new_operation("RiscCholesky", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RiscCholeskyInst { op })
    }
}
impl RiscCholeskyInst {
    /// Returns the 'output' Output of this 'RiscCholesky' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'RiscCholesky' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<RiscCholeskyInst> for crate::Operation {
    fn from(inst: RiscCholeskyInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RiscCholesky::new().build(input, scope)`.
pub fn risc_cholesky<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RiscCholesky::new().build(input, scope)
}

/// Builder for the `RiscConcat` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RiscConcat {
    N: ::std::option::Option<i64>,
    T: ::std::option::Option<crate::DataType>,
    Tidx: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RiscConcat' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RiscConcatInst {
    /// An instance of a fully built RiscConcat Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RiscConcat {
    /// Creates a new `RiscConcat`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `N` attribute.
    pub fn N<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.N = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tidx` attribute.
    pub fn Tidx<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Tidx = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RiscConcat` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        values: O0,
        axis: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(values.into(), axis.into(), scope)
    }
    fn build_impl(
        &self,
        values: crate::Output,
        axis: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("RiscConcat", |nd| {
            nd.add_input(values);
            nd.add_input(axis);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.N {
                nd.set_attr_int("N", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tidx {
                nd.set_attr_type("Tidx", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RiscConcat' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        values: Vec<crate::Output>,
        axis: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<RiscConcatInst> {
        let op = scope.new_operation("RiscConcat", |builder| {
            builder.add_input_list(&values);
            builder.add_input(axis);
            builder.set_attr_int("N", values.clone().len() as i64)?;
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tidx {
                builder.set_attr_type("Tidx", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RiscConcatInst { op })
    }
}
impl RiscConcatInst {
    /// Returns the 'output' Output of this 'RiscConcat' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns a Vector of values for 'values' Input of this RiscConcat operation.
    pub fn values(&self) -> crate::Result<Vec<crate::Input>> {
        let mut Inputs = vec![];
        for i in 0..self.op.get_attr_int("N")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
    /// Returns the 'axis' Input of this 'RiscConcat' operation.
    pub fn axis(&self) -> crate::Result<crate::Input> {
        let dynamic_offset = (self.op.get_attr_int("N")? + 1) as i32;
        Ok(crate::Input {
            operation: &self.op,
            index: dynamic_offset,
        })
    }
}
impl From<RiscConcatInst> for crate::Operation {
    fn from(inst: RiscConcatInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RiscConcat::new().build(values, axis, scope)`.
pub fn risc_concat<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    values: O0,
    axis: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RiscConcat::new().build(values, axis, scope)
}

/// Builder for the `RiscCondition` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RiscCondition {
    func_true: ::std::option::Option<::std::string::String>,
    func_false: ::std::option::Option<::std::string::String>,
    SrcT: ::std::option::Option<crate::DataType>,
    DstT: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RiscCondition' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RiscConditionInst {
    /// An instance of a fully built RiscCondition Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RiscCondition {
    /// Creates a new `RiscCondition`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `func_true` attribute.
    pub fn func_true<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.func_true = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `func_false` attribute.
    pub fn func_false<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.func_false = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `SrcT` attribute.
    pub fn SrcT<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.SrcT = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `DstT` attribute.
    pub fn DstT<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.DstT = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RiscCondition` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        pred: O0,
        input_true: O1,
        input_false: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(pred.into(), input_true.into(), input_false.into(), scope)
    }
    fn build_impl(
        &self,
        pred: crate::Output,
        input_true: crate::Output,
        input_false: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("RiscCondition", |nd| {
            nd.add_input(pred);
            nd.add_input(input_true);
            nd.add_input(input_false);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.func_true {
                nd.set_attr_string("func_true", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.func_false {
                nd.set_attr_string("func_false", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.SrcT {
                nd.set_attr_type("SrcT", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.DstT {
                nd.set_attr_type("DstT", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RiscCondition' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        pred: crate::Output,
        input_true: crate::Output,
        input_false: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<RiscConditionInst> {
        let op = scope.new_operation("RiscCondition", |builder| {
            builder.add_input(pred);
            builder.add_input(input_true);
            builder.add_input(input_false);
            if let ::std::option::Option::Some(value) = &self.func_true {
                builder.set_attr_string("func_true", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.func_false {
                builder.set_attr_string("func_false", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.SrcT {
                builder.set_attr_type("SrcT", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.DstT {
                builder.set_attr_type("DstT", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RiscConditionInst { op })
    }
}
impl RiscConditionInst {
    /// Returns the 'output' Output of this 'RiscCondition' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'pred' Input of this 'RiscCondition' operation.
    pub fn pred(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'input_true' Input of this 'RiscCondition' operation.
    pub fn input_true(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'input_false' Input of this 'RiscCondition' operation.
    pub fn input_false(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<RiscConditionInst> for crate::Operation {
    fn from(inst: RiscConditionInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RiscCondition::new().build(pred, input_true, input_false, scope)`.
pub fn risc_condition<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    pred: O0,
    input_true: O1,
    input_false: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RiscCondition::new().build(pred, input_true, input_false, scope)
}

/// Builder for the `RiscConv` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RiscConv {
    T: ::std::option::Option<crate::DataType>,
    strides: ::std::option::Option<::std::vec::Vec<i64>>,
    data_format: ::std::option::Option<::std::string::String>,
    dilations: ::std::option::Option<::std::vec::Vec<i64>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RiscConv' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RiscConvInst {
    /// An instance of a fully built RiscConv Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RiscConv {
    /// Creates a new `RiscConv`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `strides` attribute.
    pub fn strides<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.strides = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `data_format` attribute.
    pub fn data_format<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.data_format = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `dilations` attribute.
    pub fn dilations<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.dilations = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RiscConv` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        filter: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), filter.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        filter: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("RiscConv", |nd| {
            nd.add_input(input);
            nd.add_input(filter);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.strides {
                nd.set_attr_int_list("strides", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.data_format {
                nd.set_attr_string("data_format", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dilations {
                nd.set_attr_int_list("dilations", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RiscConv' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        filter: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<RiscConvInst> {
        let op = scope.new_operation("RiscConv", |builder| {
            builder.add_input(input);
            builder.add_input(filter);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.strides {
                builder.set_attr_int_list("strides", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.data_format {
                builder.set_attr_string("data_format", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dilations {
                builder.set_attr_int_list("dilations", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RiscConvInst { op })
    }
}
impl RiscConvInst {
    /// Returns the 'output' Output of this 'RiscConv' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'RiscConv' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'filter' Input of this 'RiscConv' operation.
    pub fn filter(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<RiscConvInst> for crate::Operation {
    fn from(inst: RiscConvInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RiscConv::new().build(input, filter, scope)`.
pub fn risc_conv<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    input: O0,
    filter: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RiscConv::new().build(input, filter, scope)
}

/// Builder for the `RiscCos` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RiscCos {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RiscCos' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RiscCosInst {
    /// An instance of a fully built RiscCos Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RiscCos {
    /// Creates a new `RiscCos`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RiscCos` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        x: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("RiscCos", |nd| {
            nd.add_input(x);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RiscCos' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<RiscCosInst> {
        let op = scope.new_operation("RiscCos", |builder| {
            builder.add_input(x);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RiscCosInst { op })
    }
}
impl RiscCosInst {
    /// Returns the 'y' Output of this 'RiscCos' operation.
    pub fn y(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'RiscCos' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<RiscCosInst> for crate::Operation {
    fn from(inst: RiscCosInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RiscCos::new().build(x, scope)`.
pub fn risc_cos<O0: ::std::convert::Into<crate::Output>>(
    x: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RiscCos::new().build(x, scope)
}

/// Builder for the `RiscDiv` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RiscDiv {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RiscDiv' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RiscDivInst {
    /// An instance of a fully built RiscDiv Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RiscDiv {
    /// Creates a new `RiscDiv`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RiscDiv` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        x: O0,
        y: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), y.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        y: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("RiscDiv", |nd| {
            nd.add_input(x);
            nd.add_input(y);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RiscDiv' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        y: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<RiscDivInst> {
        let op = scope.new_operation("RiscDiv", |builder| {
            builder.add_input(x);
            builder.add_input(y);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RiscDivInst { op })
    }
}
impl RiscDivInst {
    /// Returns the 'z' Output of this 'RiscDiv' operation.
    pub fn z(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'RiscDiv' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'y' Input of this 'RiscDiv' operation.
    pub fn y(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<RiscDivInst> for crate::Operation {
    fn from(inst: RiscDivInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RiscDiv::new().build(x, y, scope)`.
pub fn risc_div<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    x: O0,
    y: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RiscDiv::new().build(x, y, scope)
}

/// Builder for the `RiscDot` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RiscDot {
    transpose_a: ::std::option::Option<bool>,
    transpose_b: ::std::option::Option<bool>,
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RiscDot' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RiscDotInst {
    /// An instance of a fully built RiscDot Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RiscDot {
    /// Creates a new `RiscDot`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `transpose_a` attribute.
    pub fn transpose_a<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.transpose_a = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `transpose_b` attribute.
    pub fn transpose_b<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.transpose_b = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RiscDot` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        a: O0,
        b: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(a.into(), b.into(), scope)
    }
    fn build_impl(
        &self,
        a: crate::Output,
        b: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("RiscDot", |nd| {
            nd.add_input(a);
            nd.add_input(b);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.transpose_a {
                nd.set_attr_bool("transpose_a", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.transpose_b {
                nd.set_attr_bool("transpose_b", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RiscDot' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        a: crate::Output,
        b: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<RiscDotInst> {
        let op = scope.new_operation("RiscDot", |builder| {
            builder.add_input(a);
            builder.add_input(b);
            if let ::std::option::Option::Some(value) = &self.transpose_a {
                builder.set_attr_bool("transpose_a", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.transpose_b {
                builder.set_attr_bool("transpose_b", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RiscDotInst { op })
    }
}
impl RiscDotInst {
    /// Returns the 'product' Output of this 'RiscDot' operation.
    pub fn product(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'a' Input of this 'RiscDot' operation.
    pub fn a(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'b' Input of this 'RiscDot' operation.
    pub fn b(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<RiscDotInst> for crate::Operation {
    fn from(inst: RiscDotInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RiscDot::new().build(a, b, scope)`.
pub fn risc_dot<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    a: O0,
    b: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RiscDot::new().build(a, b, scope)
}

/// Builder for the `RiscExp` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RiscExp {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RiscExp' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RiscExpInst {
    /// An instance of a fully built RiscExp Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RiscExp {
    /// Creates a new `RiscExp`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RiscExp` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        x: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("RiscExp", |nd| {
            nd.add_input(x);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RiscExp' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<RiscExpInst> {
        let op = scope.new_operation("RiscExp", |builder| {
            builder.add_input(x);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RiscExpInst { op })
    }
}
impl RiscExpInst {
    /// Returns the 'y' Output of this 'RiscExp' operation.
    pub fn y(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'RiscExp' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<RiscExpInst> for crate::Operation {
    fn from(inst: RiscExpInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RiscExp::new().build(x, scope)`.
pub fn risc_exp<O0: ::std::convert::Into<crate::Output>>(
    x: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RiscExp::new().build(x, scope)
}

/// Builder for the `RiscFft` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RiscFft {
    Tcomplex: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RiscFft' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RiscFftInst {
    /// An instance of a fully built RiscFft Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RiscFft {
    /// Creates a new `RiscFft`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `Tcomplex` attribute.
    pub fn Tcomplex<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tcomplex = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RiscFft` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("RiscFft", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.Tcomplex {
                nd.set_attr_type("Tcomplex", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RiscFft' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<RiscFftInst> {
        let op = scope.new_operation("RiscFft", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.Tcomplex {
                builder.set_attr_type("Tcomplex", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RiscFftInst { op })
    }
}
impl RiscFftInst {
    /// Returns the 'output' Output of this 'RiscFft' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'RiscFft' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<RiscFftInst> for crate::Operation {
    fn from(inst: RiscFftInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RiscFft::new().build(input, scope)`.
pub fn risc_fft<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RiscFft::new().build(input, scope)
}

/// Builder for the `RiscFloor` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RiscFloor {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RiscFloor' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RiscFloorInst {
    /// An instance of a fully built RiscFloor Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RiscFloor {
    /// Creates a new `RiscFloor`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RiscFloor` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        x: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("RiscFloor", |nd| {
            nd.add_input(x);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RiscFloor' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<RiscFloorInst> {
        let op = scope.new_operation("RiscFloor", |builder| {
            builder.add_input(x);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RiscFloorInst { op })
    }
}
impl RiscFloorInst {
    /// Returns the 'y' Output of this 'RiscFloor' operation.
    pub fn y(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'RiscFloor' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<RiscFloorInst> for crate::Operation {
    fn from(inst: RiscFloorInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RiscFloor::new().build(x, scope)`.
pub fn risc_floor<O0: ::std::convert::Into<crate::Output>>(
    x: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RiscFloor::new().build(x, scope)
}

/// Builder for the `RiscGather` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RiscGather {
    batch_dims: ::std::option::Option<i64>,
    Tparams: ::std::option::Option<crate::DataType>,
    Tindices: ::std::option::Option<crate::DataType>,
    Taxis: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RiscGather' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RiscGatherInst {
    /// An instance of a fully built RiscGather Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RiscGather {
    /// Creates a new `RiscGather`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `batch_dims` attribute.
    pub fn batch_dims<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.batch_dims = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tparams` attribute.
    pub fn Tparams<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tparams = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tindices` attribute.
    pub fn Tindices<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tindices = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Taxis` attribute.
    pub fn Taxis<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Taxis = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RiscGather` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        params: O0,
        indices: O1,
        axis: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(params.into(), indices.into(), axis.into(), scope)
    }
    fn build_impl(
        &self,
        params: crate::Output,
        indices: crate::Output,
        axis: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("RiscGather", |nd| {
            nd.add_input(params);
            nd.add_input(indices);
            nd.add_input(axis);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.batch_dims {
                nd.set_attr_int("batch_dims", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tparams {
                nd.set_attr_type("Tparams", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                nd.set_attr_type("Tindices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Taxis {
                nd.set_attr_type("Taxis", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RiscGather' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        params: crate::Output,
        indices: crate::Output,
        axis: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<RiscGatherInst> {
        let op = scope.new_operation("RiscGather", |builder| {
            builder.add_input(params);
            builder.add_input(indices);
            builder.add_input(axis);
            if let ::std::option::Option::Some(value) = &self.batch_dims {
                builder.set_attr_int("batch_dims", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tparams {
                builder.set_attr_type("Tparams", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                builder.set_attr_type("Tindices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Taxis {
                builder.set_attr_type("Taxis", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RiscGatherInst { op })
    }
}
impl RiscGatherInst {
    /// Returns the 'output' Output of this 'RiscGather' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'params' Input of this 'RiscGather' operation.
    pub fn params(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'indices' Input of this 'RiscGather' operation.
    pub fn indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'axis' Input of this 'RiscGather' operation.
    pub fn axis(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<RiscGatherInst> for crate::Operation {
    fn from(inst: RiscGatherInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RiscGather::new().build(params, indices, axis, scope)`.
pub fn risc_gather<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    params: O0,
    indices: O1,
    axis: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RiscGather::new().build(params, indices, axis, scope)
}

/// Builder for the `RiscImag` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RiscImag {
    T: ::std::option::Option<crate::DataType>,
    Tout: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RiscImag' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RiscImagInst {
    /// An instance of a fully built RiscImag Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RiscImag {
    /// Creates a new `RiscImag`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tout` attribute.
    pub fn Tout<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Tout = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RiscImag` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("RiscImag", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tout {
                nd.set_attr_type("Tout", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RiscImag' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<RiscImagInst> {
        let op = scope.new_operation("RiscImag", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tout {
                builder.set_attr_type("Tout", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RiscImagInst { op })
    }
}
impl RiscImagInst {
    /// Returns the 'output' Output of this 'RiscImag' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'RiscImag' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<RiscImagInst> for crate::Operation {
    fn from(inst: RiscImagInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RiscImag::new().build(input, scope)`.
pub fn risc_imag<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RiscImag::new().build(input, scope)
}

/// Builder for the `RiscIsFinite` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RiscIsFinite {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RiscIsFinite' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RiscIsFiniteInst {
    /// An instance of a fully built RiscIsFinite Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RiscIsFinite {
    /// Creates a new `RiscIsFinite`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RiscIsFinite` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        x: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("RiscIsFinite", |nd| {
            nd.add_input(x);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RiscIsFinite' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<RiscIsFiniteInst> {
        let op = scope.new_operation("RiscIsFinite", |builder| {
            builder.add_input(x);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RiscIsFiniteInst { op })
    }
}
impl RiscIsFiniteInst {
    /// Returns the 'y' Output of this 'RiscIsFinite' operation.
    pub fn y(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'RiscIsFinite' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<RiscIsFiniteInst> for crate::Operation {
    fn from(inst: RiscIsFiniteInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RiscIsFinite::new().build(x, scope)`.
pub fn risc_is_finite<O0: ::std::convert::Into<crate::Output>>(
    x: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RiscIsFinite::new().build(x, scope)
}

/// Builder for the `RiscLog` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RiscLog {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RiscLog' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RiscLogInst {
    /// An instance of a fully built RiscLog Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RiscLog {
    /// Creates a new `RiscLog`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RiscLog` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        x: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("RiscLog", |nd| {
            nd.add_input(x);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RiscLog' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<RiscLogInst> {
        let op = scope.new_operation("RiscLog", |builder| {
            builder.add_input(x);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RiscLogInst { op })
    }
}
impl RiscLogInst {
    /// Returns the 'y' Output of this 'RiscLog' operation.
    pub fn y(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'RiscLog' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<RiscLogInst> for crate::Operation {
    fn from(inst: RiscLogInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RiscLog::new().build(x, scope)`.
pub fn risc_log<O0: ::std::convert::Into<crate::Output>>(
    x: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RiscLog::new().build(x, scope)
}

/// Builder for the `RiscLogicalAnd` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RiscLogicalAnd {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RiscLogicalAnd' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RiscLogicalAndInst {
    /// An instance of a fully built RiscLogicalAnd Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RiscLogicalAnd {
    /// Creates a new `RiscLogicalAnd`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RiscLogicalAnd` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        x: O0,
        y: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), y.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        y: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("RiscLogicalAnd", |nd| {
            nd.add_input(x);
            nd.add_input(y);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RiscLogicalAnd' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        y: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<RiscLogicalAndInst> {
        let op = scope.new_operation("RiscLogicalAnd", |builder| {
            builder.add_input(x);
            builder.add_input(y);
            ::std::result::Result::Ok(())
        })?;
        Ok(RiscLogicalAndInst { op })
    }
}
impl RiscLogicalAndInst {
    /// Returns the 'z' Output of this 'RiscLogicalAnd' operation.
    pub fn z(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'RiscLogicalAnd' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'y' Input of this 'RiscLogicalAnd' operation.
    pub fn y(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<RiscLogicalAndInst> for crate::Operation {
    fn from(inst: RiscLogicalAndInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RiscLogicalAnd::new().build(x, y, scope)`.
pub fn risc_logical_and<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    x: O0,
    y: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RiscLogicalAnd::new().build(x, y, scope)
}

/// Builder for the `RiscLogicalNot` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RiscLogicalNot {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RiscLogicalNot' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RiscLogicalNotInst {
    /// An instance of a fully built RiscLogicalNot Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RiscLogicalNot {
    /// Creates a new `RiscLogicalNot`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RiscLogicalNot` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        x: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("RiscLogicalNot", |nd| {
            nd.add_input(x);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RiscLogicalNot' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<RiscLogicalNotInst> {
        let op = scope.new_operation("RiscLogicalNot", |builder| {
            builder.add_input(x);
            ::std::result::Result::Ok(())
        })?;
        Ok(RiscLogicalNotInst { op })
    }
}
impl RiscLogicalNotInst {
    /// Returns the 'z' Output of this 'RiscLogicalNot' operation.
    pub fn z(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'RiscLogicalNot' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<RiscLogicalNotInst> for crate::Operation {
    fn from(inst: RiscLogicalNotInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RiscLogicalNot::new().build(x, scope)`.
pub fn risc_logical_not<O0: ::std::convert::Into<crate::Output>>(
    x: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RiscLogicalNot::new().build(x, scope)
}

/// Builder for the `RiscLogicalOr` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RiscLogicalOr {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RiscLogicalOr' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RiscLogicalOrInst {
    /// An instance of a fully built RiscLogicalOr Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RiscLogicalOr {
    /// Creates a new `RiscLogicalOr`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RiscLogicalOr` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        x: O0,
        y: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), y.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        y: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("RiscLogicalOr", |nd| {
            nd.add_input(x);
            nd.add_input(y);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RiscLogicalOr' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        y: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<RiscLogicalOrInst> {
        let op = scope.new_operation("RiscLogicalOr", |builder| {
            builder.add_input(x);
            builder.add_input(y);
            ::std::result::Result::Ok(())
        })?;
        Ok(RiscLogicalOrInst { op })
    }
}
impl RiscLogicalOrInst {
    /// Returns the 'z' Output of this 'RiscLogicalOr' operation.
    pub fn z(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'RiscLogicalOr' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'y' Input of this 'RiscLogicalOr' operation.
    pub fn y(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<RiscLogicalOrInst> for crate::Operation {
    fn from(inst: RiscLogicalOrInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RiscLogicalOr::new().build(x, y, scope)`.
pub fn risc_logical_or<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    x: O0,
    y: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RiscLogicalOr::new().build(x, y, scope)
}

/// Builder for the `RiscMax` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RiscMax {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RiscMax' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RiscMaxInst {
    /// An instance of a fully built RiscMax Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RiscMax {
    /// Creates a new `RiscMax`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RiscMax` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        x: O0,
        y: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), y.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        y: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("RiscMax", |nd| {
            nd.add_input(x);
            nd.add_input(y);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RiscMax' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        y: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<RiscMaxInst> {
        let op = scope.new_operation("RiscMax", |builder| {
            builder.add_input(x);
            builder.add_input(y);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RiscMaxInst { op })
    }
}
impl RiscMaxInst {
    /// Returns the 'max' Output of this 'RiscMax' operation.
    pub fn max(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'RiscMax' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'y' Input of this 'RiscMax' operation.
    pub fn y(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<RiscMaxInst> for crate::Operation {
    fn from(inst: RiscMaxInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RiscMax::new().build(x, y, scope)`.
pub fn risc_max<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    x: O0,
    y: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RiscMax::new().build(x, y, scope)
}

/// Builder for the `RiscMin` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RiscMin {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RiscMin' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RiscMinInst {
    /// An instance of a fully built RiscMin Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RiscMin {
    /// Creates a new `RiscMin`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RiscMin` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        x: O0,
        y: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), y.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        y: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("RiscMin", |nd| {
            nd.add_input(x);
            nd.add_input(y);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RiscMin' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        y: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<RiscMinInst> {
        let op = scope.new_operation("RiscMin", |builder| {
            builder.add_input(x);
            builder.add_input(y);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RiscMinInst { op })
    }
}
impl RiscMinInst {
    /// Returns the 'z' Output of this 'RiscMin' operation.
    pub fn z(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'RiscMin' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'y' Input of this 'RiscMin' operation.
    pub fn y(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<RiscMinInst> for crate::Operation {
    fn from(inst: RiscMinInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RiscMin::new().build(x, y, scope)`.
pub fn risc_min<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    x: O0,
    y: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RiscMin::new().build(x, y, scope)
}

/// Builder for the `RiscMul` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RiscMul {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RiscMul' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RiscMulInst {
    /// An instance of a fully built RiscMul Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RiscMul {
    /// Creates a new `RiscMul`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RiscMul` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        x: O0,
        y: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), y.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        y: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("RiscMul", |nd| {
            nd.add_input(x);
            nd.add_input(y);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RiscMul' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        y: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<RiscMulInst> {
        let op = scope.new_operation("RiscMul", |builder| {
            builder.add_input(x);
            builder.add_input(y);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RiscMulInst { op })
    }
}
impl RiscMulInst {
    /// Returns the 'z' Output of this 'RiscMul' operation.
    pub fn z(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'RiscMul' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'y' Input of this 'RiscMul' operation.
    pub fn y(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<RiscMulInst> for crate::Operation {
    fn from(inst: RiscMulInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RiscMul::new().build(x, y, scope)`.
pub fn risc_mul<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    x: O0,
    y: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RiscMul::new().build(x, y, scope)
}

/// Builder for the `RiscNeg` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RiscNeg {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RiscNeg' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RiscNegInst {
    /// An instance of a fully built RiscNeg Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RiscNeg {
    /// Creates a new `RiscNeg`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RiscNeg` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        x: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("RiscNeg", |nd| {
            nd.add_input(x);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RiscNeg' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<RiscNegInst> {
        let op = scope.new_operation("RiscNeg", |builder| {
            builder.add_input(x);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RiscNegInst { op })
    }
}
impl RiscNegInst {
    /// Returns the 'y' Output of this 'RiscNeg' operation.
    pub fn y(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'RiscNeg' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<RiscNegInst> for crate::Operation {
    fn from(inst: RiscNegInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RiscNeg::new().build(x, scope)`.
pub fn risc_neg<O0: ::std::convert::Into<crate::Output>>(
    x: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RiscNeg::new().build(x, scope)
}

/// Builder for the `RiscPad` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RiscPad {
    T: ::std::option::Option<crate::DataType>,
    Tpaddings: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RiscPad' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RiscPadInst {
    /// An instance of a fully built RiscPad Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RiscPad {
    /// Creates a new `RiscPad`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tpaddings` attribute.
    pub fn Tpaddings<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tpaddings = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RiscPad` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        paddings: O1,
        constant_values: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), paddings.into(), constant_values.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        paddings: crate::Output,
        constant_values: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("RiscPad", |nd| {
            nd.add_input(input);
            nd.add_input(paddings);
            nd.add_input(constant_values);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tpaddings {
                nd.set_attr_type("Tpaddings", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RiscPad' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        paddings: crate::Output,
        constant_values: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<RiscPadInst> {
        let op = scope.new_operation("RiscPad", |builder| {
            builder.add_input(input);
            builder.add_input(paddings);
            builder.add_input(constant_values);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tpaddings {
                builder.set_attr_type("Tpaddings", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RiscPadInst { op })
    }
}
impl RiscPadInst {
    /// Returns the 'output' Output of this 'RiscPad' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'RiscPad' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'paddings' Input of this 'RiscPad' operation.
    pub fn paddings(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'constant_values' Input of this 'RiscPad' operation.
    pub fn constant_values(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<RiscPadInst> for crate::Operation {
    fn from(inst: RiscPadInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RiscPad::new().build(input, paddings, constant_values, scope)`.
pub fn risc_pad<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    input: O0,
    paddings: O1,
    constant_values: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RiscPad::new().build(input, paddings, constant_values, scope)
}

/// Builder for the `RiscPool` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RiscPool {
    ksize: ::std::option::Option<::std::vec::Vec<i64>>,
    strides: ::std::option::Option<::std::vec::Vec<i64>>,
    pooling_type: ::std::option::Option<::std::string::String>,
    data_format: ::std::option::Option<::std::string::String>,
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RiscPool' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RiscPoolInst {
    /// An instance of a fully built RiscPool Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RiscPool {
    /// Creates a new `RiscPool`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `ksize` attribute.
    pub fn ksize<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.ksize = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `strides` attribute.
    pub fn strides<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.strides = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `pooling_type` attribute.
    pub fn pooling_type<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.pooling_type = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `data_format` attribute.
    pub fn data_format<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.data_format = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RiscPool` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        value: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(value.into(), scope)
    }
    fn build_impl(
        &self,
        value: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("RiscPool", |nd| {
            nd.add_input(value);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.ksize {
                nd.set_attr_int_list("ksize", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.strides {
                nd.set_attr_int_list("strides", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.pooling_type {
                nd.set_attr_string("pooling_type", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.data_format {
                nd.set_attr_string("data_format", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RiscPool' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        value: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<RiscPoolInst> {
        let op = scope.new_operation("RiscPool", |builder| {
            builder.add_input(value);
            if let ::std::option::Option::Some(value) = &self.ksize {
                builder.set_attr_int_list("ksize", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.strides {
                builder.set_attr_int_list("strides", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.pooling_type {
                builder.set_attr_string("pooling_type", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.data_format {
                builder.set_attr_string("data_format", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RiscPoolInst { op })
    }
}
impl RiscPoolInst {
    /// Returns the 'output' Output of this 'RiscPool' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'value' Input of this 'RiscPool' operation.
    pub fn value(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<RiscPoolInst> for crate::Operation {
    fn from(inst: RiscPoolInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RiscPool::new().build(value, scope)`.
pub fn risc_pool<O0: ::std::convert::Into<crate::Output>>(
    value: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RiscPool::new().build(value, scope)
}

/// Builder for the `RiscPow` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RiscPow {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RiscPow' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RiscPowInst {
    /// An instance of a fully built RiscPow Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RiscPow {
    /// Creates a new `RiscPow`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RiscPow` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        x: O0,
        y: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), y.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        y: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("RiscPow", |nd| {
            nd.add_input(x);
            nd.add_input(y);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RiscPow' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        y: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<RiscPowInst> {
        let op = scope.new_operation("RiscPow", |builder| {
            builder.add_input(x);
            builder.add_input(y);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RiscPowInst { op })
    }
}
impl RiscPowInst {
    /// Returns the 'z' Output of this 'RiscPow' operation.
    pub fn z(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'RiscPow' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'y' Input of this 'RiscPow' operation.
    pub fn y(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<RiscPowInst> for crate::Operation {
    fn from(inst: RiscPowInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RiscPow::new().build(x, y, scope)`.
pub fn risc_pow<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    x: O0,
    y: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RiscPow::new().build(x, y, scope)
}

/// Builder for the `RiscRandomUniform` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RiscRandomUniform {
    seed: ::std::option::Option<i64>,
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RiscRandomUniform' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RiscRandomUniformInst {
    /// An instance of a fully built RiscRandomUniform Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RiscRandomUniform {
    /// Creates a new `RiscRandomUniform`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `seed` attribute.
    pub fn seed<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.seed = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RiscRandomUniform` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        shape: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(shape.into(), scope)
    }
    fn build_impl(
        &self,
        shape: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("RiscRandomUniform", |nd| {
            nd.add_input(shape);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.seed {
                nd.set_attr_int("seed", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RiscRandomUniform' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        shape: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<RiscRandomUniformInst> {
        let op = scope.new_operation("RiscRandomUniform", |builder| {
            builder.add_input(shape);
            if let ::std::option::Option::Some(value) = &self.seed {
                builder.set_attr_int("seed", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RiscRandomUniformInst { op })
    }
}
impl RiscRandomUniformInst {
    /// Returns the 'output' Output of this 'RiscRandomUniform' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'shape' Input of this 'RiscRandomUniform' operation.
    pub fn shape(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<RiscRandomUniformInst> for crate::Operation {
    fn from(inst: RiscRandomUniformInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RiscRandomUniform::new().build(shape, scope)`.
pub fn risc_random_uniform<O0: ::std::convert::Into<crate::Output>>(
    shape: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RiscRandomUniform::new().build(shape, scope)
}

/// Builder for the `RiscReal` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RiscReal {
    T: ::std::option::Option<crate::DataType>,
    Tout: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RiscReal' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RiscRealInst {
    /// An instance of a fully built RiscReal Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RiscReal {
    /// Creates a new `RiscReal`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tout` attribute.
    pub fn Tout<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Tout = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RiscReal` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("RiscReal", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tout {
                nd.set_attr_type("Tout", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RiscReal' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<RiscRealInst> {
        let op = scope.new_operation("RiscReal", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tout {
                builder.set_attr_type("Tout", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RiscRealInst { op })
    }
}
impl RiscRealInst {
    /// Returns the 'output' Output of this 'RiscReal' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'RiscReal' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<RiscRealInst> for crate::Operation {
    fn from(inst: RiscRealInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RiscReal::new().build(input, scope)`.
pub fn risc_real<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RiscReal::new().build(input, scope)
}

/// Builder for the `RiscReduce` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RiscReduce {
    reduce_type: ::std::option::Option<::std::string::String>,
    Index: ::std::option::Option<crate::DataType>,
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RiscReduce' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RiscReduceInst {
    /// An instance of a fully built RiscReduce Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RiscReduce {
    /// Creates a new `RiscReduce`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `reduce_type` attribute.
    pub fn reduce_type<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.reduce_type = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Index` attribute.
    pub fn Index<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Index = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RiscReduce` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        tensor: O0,
        axis: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(tensor.into(), axis.into(), scope)
    }
    fn build_impl(
        &self,
        tensor: crate::Output,
        axis: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("RiscReduce", |nd| {
            nd.add_input(tensor);
            nd.add_input(axis);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.reduce_type {
                nd.set_attr_string("reduce_type", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Index {
                nd.set_attr_type("Index", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RiscReduce' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        tensor: crate::Output,
        axis: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<RiscReduceInst> {
        let op = scope.new_operation("RiscReduce", |builder| {
            builder.add_input(tensor);
            builder.add_input(axis);
            if let ::std::option::Option::Some(value) = &self.reduce_type {
                builder.set_attr_string("reduce_type", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Index {
                builder.set_attr_type("Index", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RiscReduceInst { op })
    }
}
impl RiscReduceInst {
    /// Returns the 'output' Output of this 'RiscReduce' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'tensor' Input of this 'RiscReduce' operation.
    pub fn tensor(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'axis' Input of this 'RiscReduce' operation.
    pub fn axis(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<RiscReduceInst> for crate::Operation {
    fn from(inst: RiscReduceInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RiscReduce::new().build(tensor, axis, scope)`.
pub fn risc_reduce<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    tensor: O0,
    axis: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RiscReduce::new().build(tensor, axis, scope)
}

/// Builder for the `RiscRem` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RiscRem {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RiscRem' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RiscRemInst {
    /// An instance of a fully built RiscRem Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RiscRem {
    /// Creates a new `RiscRem`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RiscRem` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        x: O0,
        y: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), y.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        y: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("RiscRem", |nd| {
            nd.add_input(x);
            nd.add_input(y);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RiscRem' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        y: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<RiscRemInst> {
        let op = scope.new_operation("RiscRem", |builder| {
            builder.add_input(x);
            builder.add_input(y);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RiscRemInst { op })
    }
}
impl RiscRemInst {
    /// Returns the 'z' Output of this 'RiscRem' operation.
    pub fn z(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'RiscRem' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'y' Input of this 'RiscRem' operation.
    pub fn y(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<RiscRemInst> for crate::Operation {
    fn from(inst: RiscRemInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RiscRem::new().build(x, y, scope)`.
pub fn risc_rem<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    x: O0,
    y: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RiscRem::new().build(x, y, scope)
}

/// Builder for the `RiscReshape` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RiscReshape {
    T: ::std::option::Option<crate::DataType>,
    Tshape: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RiscReshape' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RiscReshapeInst {
    /// An instance of a fully built RiscReshape Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RiscReshape {
    /// Creates a new `RiscReshape`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tshape` attribute.
    pub fn Tshape<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tshape = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RiscReshape` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        tensor: O0,
        shape: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(tensor.into(), shape.into(), scope)
    }
    fn build_impl(
        &self,
        tensor: crate::Output,
        shape: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("RiscReshape", |nd| {
            nd.add_input(tensor);
            nd.add_input(shape);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tshape {
                nd.set_attr_type("Tshape", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RiscReshape' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        tensor: crate::Output,
        shape: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<RiscReshapeInst> {
        let op = scope.new_operation("RiscReshape", |builder| {
            builder.add_input(tensor);
            builder.add_input(shape);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tshape {
                builder.set_attr_type("Tshape", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RiscReshapeInst { op })
    }
}
impl RiscReshapeInst {
    /// Returns the 'output' Output of this 'RiscReshape' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'tensor' Input of this 'RiscReshape' operation.
    pub fn tensor(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'shape' Input of this 'RiscReshape' operation.
    pub fn shape(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<RiscReshapeInst> for crate::Operation {
    fn from(inst: RiscReshapeInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RiscReshape::new().build(tensor, shape, scope)`.
pub fn risc_reshape<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    tensor: O0,
    shape: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RiscReshape::new().build(tensor, shape, scope)
}

/// Builder for the `RiscReverse` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RiscReverse {
    Tidx: ::std::option::Option<crate::DataType>,
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RiscReverse' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RiscReverseInst {
    /// An instance of a fully built RiscReverse Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RiscReverse {
    /// Creates a new `RiscReverse`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `Tidx` attribute.
    pub fn Tidx<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Tidx = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RiscReverse` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        tensor: O0,
        axis: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(tensor.into(), axis.into(), scope)
    }
    fn build_impl(
        &self,
        tensor: crate::Output,
        axis: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("RiscReverse", |nd| {
            nd.add_input(tensor);
            nd.add_input(axis);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.Tidx {
                nd.set_attr_type("Tidx", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RiscReverse' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        tensor: crate::Output,
        axis: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<RiscReverseInst> {
        let op = scope.new_operation("RiscReverse", |builder| {
            builder.add_input(tensor);
            builder.add_input(axis);
            if let ::std::option::Option::Some(value) = &self.Tidx {
                builder.set_attr_type("Tidx", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RiscReverseInst { op })
    }
}
impl RiscReverseInst {
    /// Returns the 'output' Output of this 'RiscReverse' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'tensor' Input of this 'RiscReverse' operation.
    pub fn tensor(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'axis' Input of this 'RiscReverse' operation.
    pub fn axis(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<RiscReverseInst> for crate::Operation {
    fn from(inst: RiscReverseInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RiscReverse::new().build(tensor, axis, scope)`.
pub fn risc_reverse<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    tensor: O0,
    axis: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RiscReverse::new().build(tensor, axis, scope)
}

/// Builder for the `RiscScatter` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RiscScatter {
    T: ::std::option::Option<crate::DataType>,
    Tindices: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RiscScatter' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RiscScatterInst {
    /// An instance of a fully built RiscScatter Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RiscScatter {
    /// Creates a new `RiscScatter`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tindices` attribute.
    pub fn Tindices<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tindices = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RiscScatter` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        indices: O0,
        updates: O1,
        shape: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(indices.into(), updates.into(), shape.into(), scope)
    }
    fn build_impl(
        &self,
        indices: crate::Output,
        updates: crate::Output,
        shape: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("RiscScatter", |nd| {
            nd.add_input(indices);
            nd.add_input(updates);
            nd.add_input(shape);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                nd.set_attr_type("Tindices", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RiscScatter' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        indices: crate::Output,
        updates: crate::Output,
        shape: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<RiscScatterInst> {
        let op = scope.new_operation("RiscScatter", |builder| {
            builder.add_input(indices);
            builder.add_input(updates);
            builder.add_input(shape);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                builder.set_attr_type("Tindices", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RiscScatterInst { op })
    }
}
impl RiscScatterInst {
    /// Returns the 'output' Output of this 'RiscScatter' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'indices' Input of this 'RiscScatter' operation.
    pub fn indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'updates' Input of this 'RiscScatter' operation.
    pub fn updates(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'shape' Input of this 'RiscScatter' operation.
    pub fn shape(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<RiscScatterInst> for crate::Operation {
    fn from(inst: RiscScatterInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RiscScatter::new().build(indices, updates, shape, scope)`.
pub fn risc_scatter<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    indices: O0,
    updates: O1,
    shape: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RiscScatter::new().build(indices, updates, shape, scope)
}

/// Builder for the `RiscShape` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RiscShape {
    T: ::std::option::Option<crate::DataType>,
    out_type: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RiscShape' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RiscShapeInst {
    /// An instance of a fully built RiscShape Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RiscShape {
    /// Creates a new `RiscShape`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `out_type` attribute.
    pub fn out_type<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.out_type = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RiscShape` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("RiscShape", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.out_type {
                nd.set_attr_type("out_type", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RiscShape' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<RiscShapeInst> {
        let op = scope.new_operation("RiscShape", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.out_type {
                builder.set_attr_type("out_type", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RiscShapeInst { op })
    }
}
impl RiscShapeInst {
    /// Returns the 'output' Output of this 'RiscShape' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'RiscShape' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<RiscShapeInst> for crate::Operation {
    fn from(inst: RiscShapeInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RiscShape::new().build(input, scope)`.
pub fn risc_shape<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RiscShape::new().build(input, scope)
}

/// Builder for the `RiscSign` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RiscSign {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RiscSign' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RiscSignInst {
    /// An instance of a fully built RiscSign Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RiscSign {
    /// Creates a new `RiscSign`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RiscSign` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        x: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("RiscSign", |nd| {
            nd.add_input(x);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RiscSign' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<RiscSignInst> {
        let op = scope.new_operation("RiscSign", |builder| {
            builder.add_input(x);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RiscSignInst { op })
    }
}
impl RiscSignInst {
    /// Returns the 'y' Output of this 'RiscSign' operation.
    pub fn y(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'RiscSign' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<RiscSignInst> for crate::Operation {
    fn from(inst: RiscSignInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RiscSign::new().build(x, scope)`.
pub fn risc_sign<O0: ::std::convert::Into<crate::Output>>(
    x: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RiscSign::new().build(x, scope)
}

/// Builder for the `RiscSlice` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RiscSlice {
    T: ::std::option::Option<crate::DataType>,
    Index: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RiscSlice' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RiscSliceInst {
    /// An instance of a fully built RiscSlice Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RiscSlice {
    /// Creates a new `RiscSlice`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Index` attribute.
    pub fn Index<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Index = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RiscSlice` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        begin: O1,
        size: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), begin.into(), size.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        begin: crate::Output,
        size: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("RiscSlice", |nd| {
            nd.add_input(input);
            nd.add_input(begin);
            nd.add_input(size);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Index {
                nd.set_attr_type("Index", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RiscSlice' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        begin: crate::Output,
        size: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<RiscSliceInst> {
        let op = scope.new_operation("RiscSlice", |builder| {
            builder.add_input(input);
            builder.add_input(begin);
            builder.add_input(size);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Index {
                builder.set_attr_type("Index", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RiscSliceInst { op })
    }
}
impl RiscSliceInst {
    /// Returns the 'output' Output of this 'RiscSlice' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'RiscSlice' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'begin' Input of this 'RiscSlice' operation.
    pub fn begin(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'size' Input of this 'RiscSlice' operation.
    pub fn size(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<RiscSliceInst> for crate::Operation {
    fn from(inst: RiscSliceInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RiscSlice::new().build(input, begin, size, scope)`.
pub fn risc_slice<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    input: O0,
    begin: O1,
    size: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RiscSlice::new().build(input, begin, size, scope)
}

/// Builder for the `RiscSort` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RiscSort {
    Index: ::std::option::Option<crate::DataType>,
    T: ::std::option::Option<crate::DataType>,
    direction: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RiscSort' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RiscSortInst {
    /// An instance of a fully built RiscSort Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RiscSort {
    /// Creates a new `RiscSort`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `Index` attribute.
    pub fn Index<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Index = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `direction` attribute.
    pub fn direction<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.direction = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RiscSort` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        axis: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), axis.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        axis: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("RiscSort", |nd| {
            nd.add_input(input);
            nd.add_input(axis);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.Index {
                nd.set_attr_type("Index", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.direction {
                nd.set_attr_string("direction", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RiscSort' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        axis: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<RiscSortInst> {
        let op = scope.new_operation("RiscSort", |builder| {
            builder.add_input(input);
            builder.add_input(axis);
            if let ::std::option::Option::Some(value) = &self.Index {
                builder.set_attr_type("Index", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.direction {
                builder.set_attr_string("direction", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RiscSortInst { op })
    }
}
impl RiscSortInst {
    /// Returns the 'output' Output of this 'RiscSort' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'RiscSort' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'axis' Input of this 'RiscSort' operation.
    pub fn axis(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<RiscSortInst> for crate::Operation {
    fn from(inst: RiscSortInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RiscSort::new().build(input, axis, scope)`.
pub fn risc_sort<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    input: O0,
    axis: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RiscSort::new().build(input, axis, scope)
}

/// Builder for the `RiscSqueeze` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RiscSqueeze {
    T: ::std::option::Option<crate::DataType>,
    squeeze_dims: ::std::option::Option<::std::vec::Vec<i64>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RiscSqueeze' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RiscSqueezeInst {
    /// An instance of a fully built RiscSqueeze Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RiscSqueeze {
    /// Creates a new `RiscSqueeze`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `squeeze_dims` attribute.
    pub fn squeeze_dims<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.squeeze_dims = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RiscSqueeze` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("RiscSqueeze", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.squeeze_dims {
                nd.set_attr_int_list("squeeze_dims", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RiscSqueeze' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<RiscSqueezeInst> {
        let op = scope.new_operation("RiscSqueeze", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.squeeze_dims {
                builder.set_attr_int_list("squeeze_dims", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RiscSqueezeInst { op })
    }
}
impl RiscSqueezeInst {
    /// Returns the 'output' Output of this 'RiscSqueeze' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'RiscSqueeze' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<RiscSqueezeInst> for crate::Operation {
    fn from(inst: RiscSqueezeInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RiscSqueeze::new().build(input, scope)`.
pub fn risc_squeeze<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RiscSqueeze::new().build(input, scope)
}

/// Builder for the `RiscSub` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RiscSub {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RiscSub' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RiscSubInst {
    /// An instance of a fully built RiscSub Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RiscSub {
    /// Creates a new `RiscSub`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RiscSub` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        x: O0,
        y: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), y.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        y: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("RiscSub", |nd| {
            nd.add_input(x);
            nd.add_input(y);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RiscSub' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        y: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<RiscSubInst> {
        let op = scope.new_operation("RiscSub", |builder| {
            builder.add_input(x);
            builder.add_input(y);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RiscSubInst { op })
    }
}
impl RiscSubInst {
    /// Returns the 'z' Output of this 'RiscSub' operation.
    pub fn z(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'RiscSub' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'y' Input of this 'RiscSub' operation.
    pub fn y(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<RiscSubInst> for crate::Operation {
    fn from(inst: RiscSubInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RiscSub::new().build(x, y, scope)`.
pub fn risc_sub<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    x: O0,
    y: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RiscSub::new().build(x, y, scope)
}

/// Builder for the `RiscTranspose` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RiscTranspose {
    T: ::std::option::Option<crate::DataType>,
    Tperm: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RiscTranspose' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RiscTransposeInst {
    /// An instance of a fully built RiscTranspose Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RiscTranspose {
    /// Creates a new `RiscTranspose`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tperm` attribute.
    pub fn Tperm<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Tperm = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RiscTranspose` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        x: O0,
        perm: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), perm.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        perm: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("RiscTranspose", |nd| {
            nd.add_input(x);
            nd.add_input(perm);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tperm {
                nd.set_attr_type("Tperm", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RiscTranspose' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        perm: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<RiscTransposeInst> {
        let op = scope.new_operation("RiscTranspose", |builder| {
            builder.add_input(x);
            builder.add_input(perm);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tperm {
                builder.set_attr_type("Tperm", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RiscTransposeInst { op })
    }
}
impl RiscTransposeInst {
    /// Returns the 'y' Output of this 'RiscTranspose' operation.
    pub fn y(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'RiscTranspose' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'perm' Input of this 'RiscTranspose' operation.
    pub fn perm(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<RiscTransposeInst> for crate::Operation {
    fn from(inst: RiscTransposeInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RiscTranspose::new().build(x, perm, scope)`.
pub fn risc_transpose<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    x: O0,
    perm: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RiscTranspose::new().build(x, perm, scope)
}

/// Builder for the `RiscTriangularSolve` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RiscTriangularSolve {
    lower: ::std::option::Option<bool>,
    adjoint: ::std::option::Option<bool>,
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RiscTriangularSolve' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RiscTriangularSolveInst {
    /// An instance of a fully built RiscTriangularSolve Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RiscTriangularSolve {
    /// Creates a new `RiscTriangularSolve`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `lower` attribute.
    pub fn lower<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.lower = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `adjoint` attribute.
    pub fn adjoint<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.adjoint = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RiscTriangularSolve` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        matrix: O0,
        rhs: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(matrix.into(), rhs.into(), scope)
    }
    fn build_impl(
        &self,
        matrix: crate::Output,
        rhs: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("RiscTriangularSolve", |nd| {
            nd.add_input(matrix);
            nd.add_input(rhs);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.lower {
                nd.set_attr_bool("lower", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.adjoint {
                nd.set_attr_bool("adjoint", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RiscTriangularSolve' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        matrix: crate::Output,
        rhs: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<RiscTriangularSolveInst> {
        let op = scope.new_operation("RiscTriangularSolve", |builder| {
            builder.add_input(matrix);
            builder.add_input(rhs);
            if let ::std::option::Option::Some(value) = &self.lower {
                builder.set_attr_bool("lower", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.adjoint {
                builder.set_attr_bool("adjoint", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RiscTriangularSolveInst { op })
    }
}
impl RiscTriangularSolveInst {
    /// Returns the 'output' Output of this 'RiscTriangularSolve' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'matrix' Input of this 'RiscTriangularSolve' operation.
    pub fn matrix(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'rhs' Input of this 'RiscTriangularSolve' operation.
    pub fn rhs(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<RiscTriangularSolveInst> for crate::Operation {
    fn from(inst: RiscTriangularSolveInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RiscTriangularSolve::new().build(matrix, rhs, scope)`.
pub fn risc_triangular_solve<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    matrix: O0,
    rhs: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RiscTriangularSolve::new().build(matrix, rhs, scope)
}

/// Builder for the `RiscUnary` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RiscUnary {
    op_type: ::std::option::Option<::std::string::String>,
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RiscUnary' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RiscUnaryInst {
    /// An instance of a fully built RiscUnary Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RiscUnary {
    /// Creates a new `RiscUnary`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `op_type` attribute.
    pub fn op_type<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.op_type = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RiscUnary` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        x: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("RiscUnary", |nd| {
            nd.add_input(x);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.op_type {
                nd.set_attr_string("op_type", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RiscUnary' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<RiscUnaryInst> {
        let op = scope.new_operation("RiscUnary", |builder| {
            builder.add_input(x);
            if let ::std::option::Option::Some(value) = &self.op_type {
                builder.set_attr_string("op_type", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RiscUnaryInst { op })
    }
}
impl RiscUnaryInst {
    /// Returns the 'y' Output of this 'RiscUnary' operation.
    pub fn y(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'RiscUnary' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<RiscUnaryInst> for crate::Operation {
    fn from(inst: RiscUnaryInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RiscUnary::new().build(x, scope)`.
pub fn risc_unary<O0: ::std::convert::Into<crate::Output>>(
    x: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RiscUnary::new().build(x, scope)
}

/// Builder for the `RiscWhile` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RiscWhile {
    T: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    cond: ::std::option::Option<::std::string::String>,
    body: ::std::option::Option<::std::string::String>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    parallel_iterations: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RiscWhile' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RiscWhileInst {
    /// An instance of a fully built RiscWhile Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RiscWhile {
    /// Creates a new `RiscWhile`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `cond` attribute.
    pub fn cond<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.cond = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `body` attribute.
    pub fn body<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.body = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `parallel_iterations` attribute.
    pub fn parallel_iterations<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.parallel_iterations = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RiscWhile` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("RiscWhile", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type_list("T", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.cond {
                nd.set_attr_string("cond", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.body {
                nd.set_attr_string("body", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.parallel_iterations {
                nd.set_attr_int("parallel_iterations", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RiscWhile' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<RiscWhileInst> {
        let op = scope.new_operation("RiscWhile", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type_list("T", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.cond {
                builder.set_attr_string("cond", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.body {
                builder.set_attr_string("body", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.parallel_iterations {
                builder.set_attr_int("parallel_iterations", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RiscWhileInst { op })
    }
}
impl RiscWhileInst {
    /// Returns the 'output' Output of this 'RiscWhile' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'RiscWhile' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<RiscWhileInst> for crate::Operation {
    fn from(inst: RiscWhileInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RiscWhile::new().build(input, scope)`.
pub fn risc_while<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RiscWhile::new().build(input, scope)
}

/// Builder for the `RngReadAndSkip` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RngReadAndSkip {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RngReadAndSkip' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RngReadAndSkipInst {
    /// An instance of a fully built RngReadAndSkip Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RngReadAndSkip {
    /// Creates a new `RngReadAndSkip`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RngReadAndSkip` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        resource: O0,
        alg: O1,
        delta: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(resource.into(), alg.into(), delta.into(), scope)
    }
    fn build_impl(
        &self,
        resource: crate::Output,
        alg: crate::Output,
        delta: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("RngReadAndSkip", |nd| {
            nd.add_input(resource);
            nd.add_input(alg);
            nd.add_input(delta);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RngReadAndSkip' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        resource: crate::Output,
        alg: crate::Output,
        delta: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<RngReadAndSkipInst> {
        let op = scope.new_operation("RngReadAndSkip", |builder| {
            builder.add_input(resource);
            builder.add_input(alg);
            builder.add_input(delta);
            ::std::result::Result::Ok(())
        })?;
        Ok(RngReadAndSkipInst { op })
    }
}
impl RngReadAndSkipInst {
    /// Returns the 'value' Output of this 'RngReadAndSkip' operation.
    pub fn value(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'resource' Input of this 'RngReadAndSkip' operation.
    pub fn resource(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'alg' Input of this 'RngReadAndSkip' operation.
    pub fn alg(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'delta' Input of this 'RngReadAndSkip' operation.
    pub fn delta(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<RngReadAndSkipInst> for crate::Operation {
    fn from(inst: RngReadAndSkipInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RngReadAndSkip::new().build(resource, alg, delta, scope)`.
pub fn rng_read_and_skip<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    resource: O0,
    alg: O1,
    delta: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RngReadAndSkip::new().build(resource, alg, delta, scope)
}

/// Builder for the `RngSkip` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RngSkip {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RngSkip' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RngSkipInst {
    /// An instance of a fully built RngSkip Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RngSkip {
    /// Creates a new `RngSkip`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RngSkip` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        resource: O0,
        algorithm: O1,
        delta: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(resource.into(), algorithm.into(), delta.into(), scope)
    }
    fn build_impl(
        &self,
        resource: crate::Output,
        algorithm: crate::Output,
        delta: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("RngSkip", |nd| {
            nd.add_input(resource);
            nd.add_input(algorithm);
            nd.add_input(delta);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RngSkip' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        resource: crate::Output,
        algorithm: crate::Output,
        delta: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<RngSkipInst> {
        let op = scope.new_operation("RngSkip", |builder| {
            builder.add_input(resource);
            builder.add_input(algorithm);
            builder.add_input(delta);
            ::std::result::Result::Ok(())
        })?;
        Ok(RngSkipInst { op })
    }
}
impl RngSkipInst {
    /// Returns the 'resource' Input of this 'RngSkip' operation.
    pub fn resource(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'algorithm' Input of this 'RngSkip' operation.
    pub fn algorithm(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'delta' Input of this 'RngSkip' operation.
    pub fn delta(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<RngSkipInst> for crate::Operation {
    fn from(inst: RngSkipInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RngSkip::new().build(resource, algorithm, delta, scope)`.
pub fn rng_skip<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    resource: O0,
    algorithm: O1,
    delta: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RngSkip::new().build(resource, algorithm, delta, scope)
}

/// Builder for the `Roll` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Roll {
    T: ::std::option::Option<crate::DataType>,
    Tshift: ::std::option::Option<crate::DataType>,
    Taxis: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Roll' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RollInst {
    /// An instance of a fully built Roll Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Roll {
    /// Creates a new `Roll`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tshift` attribute.
    pub fn Tshift<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tshift = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Taxis` attribute.
    pub fn Taxis<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Taxis = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Roll` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        shift: O1,
        axis: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), shift.into(), axis.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        shift: crate::Output,
        axis: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Roll", |nd| {
            nd.add_input(input);
            nd.add_input(shift);
            nd.add_input(axis);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tshift {
                nd.set_attr_type("Tshift", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Taxis {
                nd.set_attr_type("Taxis", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Roll' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        shift: crate::Output,
        axis: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<RollInst> {
        let op = scope.new_operation("Roll", |builder| {
            builder.add_input(input);
            builder.add_input(shift);
            builder.add_input(axis);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tshift {
                builder.set_attr_type("Tshift", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Taxis {
                builder.set_attr_type("Taxis", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RollInst { op })
    }
}
impl RollInst {
    /// Returns the 'output' Output of this 'Roll' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'Roll' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'shift' Input of this 'Roll' operation.
    pub fn shift(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'axis' Input of this 'Roll' operation.
    pub fn axis(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<RollInst> for crate::Operation {
    fn from(inst: RollInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Roll::new().build(input, shift, axis, scope)`.
pub fn roll<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    input: O0,
    shift: O1,
    axis: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Roll::new().build(input, shift, axis, scope)
}

/// Builder for the `Round` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Round {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Round' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RoundInst {
    /// An instance of a fully built Round Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Round {
    /// Creates a new `Round`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Round` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        x: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Round", |nd| {
            nd.add_input(x);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Round' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<RoundInst> {
        let op = scope.new_operation("Round", |builder| {
            builder.add_input(x);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RoundInst { op })
    }
}
impl RoundInst {
    /// Returns the 'y' Output of this 'Round' operation.
    pub fn y(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'Round' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<RoundInst> for crate::Operation {
    fn from(inst: RoundInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Round::new().build(x, scope)`.
pub fn round<O0: ::std::convert::Into<crate::Output>>(
    x: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Round::new().build(x, scope)
}

/// Builder for the `Rsqrt` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Rsqrt {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Rsqrt' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RsqrtInst {
    /// An instance of a fully built Rsqrt Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Rsqrt {
    /// Creates a new `Rsqrt`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Rsqrt` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        x: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Rsqrt", |nd| {
            nd.add_input(x);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Rsqrt' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<RsqrtInst> {
        let op = scope.new_operation("Rsqrt", |builder| {
            builder.add_input(x);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RsqrtInst { op })
    }
}
impl RsqrtInst {
    /// Returns the 'y' Output of this 'Rsqrt' operation.
    pub fn y(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'Rsqrt' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<RsqrtInst> for crate::Operation {
    fn from(inst: RsqrtInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Rsqrt::new().build(x, scope)`.
pub fn rsqrt<O0: ::std::convert::Into<crate::Output>>(
    x: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Rsqrt::new().build(x, scope)
}

/// Builder for the `RsqrtGrad` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct RsqrtGrad {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'RsqrtGrad' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct RsqrtGradInst {
    /// An instance of a fully built RsqrtGrad Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl RsqrtGrad {
    /// Creates a new `RsqrtGrad`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `RsqrtGrad` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        y: O0,
        dy: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(y.into(), dy.into(), scope)
    }
    fn build_impl(
        &self,
        y: crate::Output,
        dy: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("RsqrtGrad", |nd| {
            nd.add_input(y);
            nd.add_input(dy);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'RsqrtGrad' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        y: crate::Output,
        dy: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<RsqrtGradInst> {
        let op = scope.new_operation("RsqrtGrad", |builder| {
            builder.add_input(y);
            builder.add_input(dy);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(RsqrtGradInst { op })
    }
}
impl RsqrtGradInst {
    /// Returns the 'z' Output of this 'RsqrtGrad' operation.
    pub fn z(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'y' Input of this 'RsqrtGrad' operation.
    pub fn y(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'dy' Input of this 'RsqrtGrad' operation.
    pub fn dy(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<RsqrtGradInst> for crate::Operation {
    fn from(inst: RsqrtGradInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `RsqrtGrad::new().build(y, dy, scope)`.
pub fn rsqrt_grad<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    y: O0,
    dy: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    RsqrtGrad::new().build(y, dy, scope)
}

/// Builder for the `SampleDistortedBoundingBox` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SampleDistortedBoundingBox {
    T: ::std::option::Option<crate::DataType>,
    seed: ::std::option::Option<i64>,
    seed2: ::std::option::Option<i64>,
    min_object_covered: ::std::option::Option<f32>,
    aspect_ratio_range: ::std::option::Option<::std::vec::Vec<f32>>,
    area_range: ::std::option::Option<::std::vec::Vec<f32>>,
    max_attempts: ::std::option::Option<i64>,
    use_image_if_no_bounding_boxes: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SampleDistortedBoundingBox' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SampleDistortedBoundingBoxInst {
    /// An instance of a fully built SampleDistortedBoundingBox Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SampleDistortedBoundingBox {
    /// Creates a new `SampleDistortedBoundingBox`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `seed` attribute.
    pub fn seed<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.seed = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `seed2` attribute.
    pub fn seed2<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.seed2 = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `min_object_covered` attribute.
    pub fn min_object_covered<ArgType: ::std::convert::Into<f32>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.min_object_covered = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `aspect_ratio_range` attribute.
    pub fn aspect_ratio_range<ArgType: ::std::convert::Into<::std::vec::Vec<f32>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.aspect_ratio_range = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `area_range` attribute.
    pub fn area_range<ArgType: ::std::convert::Into<::std::vec::Vec<f32>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.area_range = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `max_attempts` attribute.
    pub fn max_attempts<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.max_attempts = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_image_if_no_bounding_boxes` attribute.
    pub fn use_image_if_no_bounding_boxes<ArgType: ::std::convert::Into<bool>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.use_image_if_no_bounding_boxes = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SampleDistortedBoundingBox` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        image_size: O0,
        bounding_boxes: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(image_size.into(), bounding_boxes.into(), scope)
    }
    fn build_impl(
        &self,
        image_size: crate::Output,
        bounding_boxes: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SampleDistortedBoundingBox", |nd| {
            nd.add_input(image_size);
            nd.add_input(bounding_boxes);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed {
                nd.set_attr_int("seed", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed2 {
                nd.set_attr_int("seed2", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.min_object_covered {
                nd.set_attr_float("min_object_covered", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.aspect_ratio_range {
                nd.set_attr_float_list("aspect_ratio_range", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.area_range {
                nd.set_attr_float_list("area_range", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.max_attempts {
                nd.set_attr_int("max_attempts", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_image_if_no_bounding_boxes {
                nd.set_attr_bool("use_image_if_no_bounding_boxes", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SampleDistortedBoundingBox' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        image_size: crate::Output,
        bounding_boxes: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SampleDistortedBoundingBoxInst> {
        let op = scope.new_operation("SampleDistortedBoundingBox", |builder| {
            builder.add_input(image_size);
            builder.add_input(bounding_boxes);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed {
                builder.set_attr_int("seed", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed2 {
                builder.set_attr_int("seed2", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.min_object_covered {
                builder.set_attr_float("min_object_covered", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.aspect_ratio_range {
                builder.set_attr_float_list("aspect_ratio_range", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.area_range {
                builder.set_attr_float_list("area_range", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.max_attempts {
                builder.set_attr_int("max_attempts", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_image_if_no_bounding_boxes {
                builder.set_attr_bool("use_image_if_no_bounding_boxes", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SampleDistortedBoundingBoxInst { op })
    }
}
impl SampleDistortedBoundingBoxInst {
    /// Returns the 'begin' Output of this 'SampleDistortedBoundingBox' operation.
    pub fn begin(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'size' Output of this 'SampleDistortedBoundingBox' operation.
    pub fn size(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'bboxes' Output of this 'SampleDistortedBoundingBox' operation.
    pub fn bboxes(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns the 'image_size' Input of this 'SampleDistortedBoundingBox' operation.
    pub fn image_size(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'bounding_boxes' Input of this 'SampleDistortedBoundingBox' operation.
    pub fn bounding_boxes(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<SampleDistortedBoundingBoxInst> for crate::Operation {
    fn from(inst: SampleDistortedBoundingBoxInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SampleDistortedBoundingBox::new().build(image_size, bounding_boxes, scope)`.
pub fn sample_distorted_bounding_box<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    image_size: O0,
    bounding_boxes: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SampleDistortedBoundingBox::new().build(image_size, bounding_boxes, scope)
}

/// Builder for the `SampleDistortedBoundingBoxV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SampleDistortedBoundingBoxV2 {
    T: ::std::option::Option<crate::DataType>,
    seed: ::std::option::Option<i64>,
    seed2: ::std::option::Option<i64>,
    aspect_ratio_range: ::std::option::Option<::std::vec::Vec<f32>>,
    area_range: ::std::option::Option<::std::vec::Vec<f32>>,
    max_attempts: ::std::option::Option<i64>,
    use_image_if_no_bounding_boxes: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SampleDistortedBoundingBoxV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SampleDistortedBoundingBoxV2Inst {
    /// An instance of a fully built SampleDistortedBoundingBoxV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SampleDistortedBoundingBoxV2 {
    /// Creates a new `SampleDistortedBoundingBoxV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `seed` attribute.
    pub fn seed<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.seed = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `seed2` attribute.
    pub fn seed2<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.seed2 = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `aspect_ratio_range` attribute.
    pub fn aspect_ratio_range<ArgType: ::std::convert::Into<::std::vec::Vec<f32>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.aspect_ratio_range = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `area_range` attribute.
    pub fn area_range<ArgType: ::std::convert::Into<::std::vec::Vec<f32>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.area_range = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `max_attempts` attribute.
    pub fn max_attempts<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.max_attempts = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_image_if_no_bounding_boxes` attribute.
    pub fn use_image_if_no_bounding_boxes<ArgType: ::std::convert::Into<bool>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.use_image_if_no_bounding_boxes = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SampleDistortedBoundingBoxV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        image_size: O0,
        bounding_boxes: O1,
        min_object_covered: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            image_size.into(),
            bounding_boxes.into(),
            min_object_covered.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        image_size: crate::Output,
        bounding_boxes: crate::Output,
        min_object_covered: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SampleDistortedBoundingBoxV2", |nd| {
            nd.add_input(image_size);
            nd.add_input(bounding_boxes);
            nd.add_input(min_object_covered);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed {
                nd.set_attr_int("seed", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed2 {
                nd.set_attr_int("seed2", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.aspect_ratio_range {
                nd.set_attr_float_list("aspect_ratio_range", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.area_range {
                nd.set_attr_float_list("area_range", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.max_attempts {
                nd.set_attr_int("max_attempts", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_image_if_no_bounding_boxes {
                nd.set_attr_bool("use_image_if_no_bounding_boxes", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SampleDistortedBoundingBoxV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        image_size: crate::Output,
        bounding_boxes: crate::Output,
        min_object_covered: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SampleDistortedBoundingBoxV2Inst> {
        let op = scope.new_operation("SampleDistortedBoundingBoxV2", |builder| {
            builder.add_input(image_size);
            builder.add_input(bounding_boxes);
            builder.add_input(min_object_covered);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed {
                builder.set_attr_int("seed", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed2 {
                builder.set_attr_int("seed2", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.aspect_ratio_range {
                builder.set_attr_float_list("aspect_ratio_range", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.area_range {
                builder.set_attr_float_list("area_range", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.max_attempts {
                builder.set_attr_int("max_attempts", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_image_if_no_bounding_boxes {
                builder.set_attr_bool("use_image_if_no_bounding_boxes", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SampleDistortedBoundingBoxV2Inst { op })
    }
}
impl SampleDistortedBoundingBoxV2Inst {
    /// Returns the 'begin' Output of this 'SampleDistortedBoundingBoxV2' operation.
    pub fn begin(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'size' Output of this 'SampleDistortedBoundingBoxV2' operation.
    pub fn size(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'bboxes' Output of this 'SampleDistortedBoundingBoxV2' operation.
    pub fn bboxes(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns the 'image_size' Input of this 'SampleDistortedBoundingBoxV2' operation.
    pub fn image_size(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'bounding_boxes' Input of this 'SampleDistortedBoundingBoxV2' operation.
    pub fn bounding_boxes(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'min_object_covered' Input of this 'SampleDistortedBoundingBoxV2' operation.
    pub fn min_object_covered(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<SampleDistortedBoundingBoxV2Inst> for crate::Operation {
    fn from(inst: SampleDistortedBoundingBoxV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SampleDistortedBoundingBoxV2::new().build(image_size, bounding_boxes, min_object_covered, scope)`.
pub fn sample_distorted_bounding_box_v2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    image_size: O0,
    bounding_boxes: O1,
    min_object_covered: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SampleDistortedBoundingBoxV2::new().build(image_size, bounding_boxes, min_object_covered, scope)
}

/// Builder for the `SamplingDataset` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SamplingDataset {
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SamplingDataset' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SamplingDatasetInst {
    /// An instance of a fully built SamplingDataset Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SamplingDataset {
    /// Creates a new `SamplingDataset`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SamplingDataset` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input_dataset: O0,
        rate: O1,
        seed: O2,
        seed2: O3,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            input_dataset.into(),
            rate.into(),
            seed.into(),
            seed2.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        input_dataset: crate::Output,
        rate: crate::Output,
        seed: crate::Output,
        seed2: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SamplingDataset", |nd| {
            nd.add_input(input_dataset);
            nd.add_input(rate);
            nd.add_input(seed);
            nd.add_input(seed2);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SamplingDataset' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_dataset: crate::Output,
        rate: crate::Output,
        seed: crate::Output,
        seed2: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SamplingDatasetInst> {
        let op = scope.new_operation("SamplingDataset", |builder| {
            builder.add_input(input_dataset);
            builder.add_input(rate);
            builder.add_input(seed);
            builder.add_input(seed2);
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SamplingDatasetInst { op })
    }
}
impl SamplingDatasetInst {
    /// Returns the 'handle' Output of this 'SamplingDataset' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_dataset' Input of this 'SamplingDataset' operation.
    pub fn input_dataset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'rate' Input of this 'SamplingDataset' operation.
    pub fn rate(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'seed' Input of this 'SamplingDataset' operation.
    pub fn seed(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'seed2' Input of this 'SamplingDataset' operation.
    pub fn seed2(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
}
impl From<SamplingDatasetInst> for crate::Operation {
    fn from(inst: SamplingDatasetInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SamplingDataset::new().build(input_dataset, rate, seed, seed2, scope)`.
pub fn sampling_dataset<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
>(
    input_dataset: O0,
    rate: O1,
    seed: O2,
    seed2: O3,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SamplingDataset::new().build(input_dataset, rate, seed, seed2, scope)
}

/// Builder for the `Save` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Save {
    T: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Save' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SaveInst {
    /// An instance of a fully built Save Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Save {
    /// Creates a new `Save`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Save` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        filename: O0,
        tensor_names: O1,
        data: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(filename.into(), tensor_names.into(), data.into(), scope)
    }
    fn build_impl(
        &self,
        filename: crate::Output,
        tensor_names: crate::Output,
        data: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Save", |nd| {
            nd.add_input(filename);
            nd.add_input(tensor_names);
            nd.add_input(data);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type_list("T", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Save' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        filename: crate::Output,
        tensor_names: crate::Output,
        data: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SaveInst> {
        let op = scope.new_operation("Save", |builder| {
            builder.add_input(filename);
            builder.add_input(tensor_names);
            builder.add_input(data);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type_list("T", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SaveInst { op })
    }
}
impl SaveInst {
    /// Returns the 'filename' Input of this 'Save' operation.
    pub fn filename(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'tensor_names' Input of this 'Save' operation.
    pub fn tensor_names(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'data' Input of this 'Save' operation.
    pub fn data(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<SaveInst> for crate::Operation {
    fn from(inst: SaveInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Save::new().build(filename, tensor_names, data, scope)`.
pub fn save<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    filename: O0,
    tensor_names: O1,
    data: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Save::new().build(filename, tensor_names, data, scope)
}

/// Builder for the `SaveDataset` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SaveDataset {
    compression: ::std::option::Option<::std::string::String>,
    shard_func: ::std::option::Option<::std::string::String>,
    use_shard_func: ::std::option::Option<bool>,
    Tshard_func_args: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SaveDataset' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SaveDatasetInst {
    /// An instance of a fully built SaveDataset Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SaveDataset {
    /// Creates a new `SaveDataset`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `compression` attribute.
    pub fn compression<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.compression = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shard_func` attribute.
    pub fn shard_func<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.shard_func = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_shard_func` attribute.
    pub fn use_shard_func<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.use_shard_func = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tshard_func_args` attribute.
    pub fn Tshard_func_args<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tshard_func_args = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SaveDataset` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input_dataset: O0,
        path: O1,
        shard_func_other_args: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            input_dataset.into(),
            path.into(),
            shard_func_other_args.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        input_dataset: crate::Output,
        path: crate::Output,
        shard_func_other_args: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SaveDataset", |nd| {
            nd.add_input(input_dataset);
            nd.add_input(path);
            nd.add_input(shard_func_other_args);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.compression {
                nd.set_attr_string("compression", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shard_func {
                nd.set_attr_string("shard_func", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_shard_func {
                nd.set_attr_bool("use_shard_func", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tshard_func_args {
                nd.set_attr_type_list("Tshard_func_args", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SaveDataset' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_dataset: crate::Output,
        path: crate::Output,
        shard_func_other_args: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SaveDatasetInst> {
        let op = scope.new_operation("SaveDataset", |builder| {
            builder.add_input(input_dataset);
            builder.add_input(path);
            builder.add_input(shard_func_other_args);
            if let ::std::option::Option::Some(value) = &self.compression {
                builder.set_attr_string("compression", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shard_func {
                builder.set_attr_string("shard_func", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_shard_func {
                builder.set_attr_bool("use_shard_func", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tshard_func_args {
                builder.set_attr_type_list("Tshard_func_args", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SaveDatasetInst { op })
    }
}
impl SaveDatasetInst {
    /// Returns the 'input_dataset' Input of this 'SaveDataset' operation.
    pub fn input_dataset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'path' Input of this 'SaveDataset' operation.
    pub fn path(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'shard_func_other_args' Input of this 'SaveDataset' operation.
    pub fn shard_func_other_args(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<SaveDatasetInst> for crate::Operation {
    fn from(inst: SaveDatasetInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SaveDataset::new().build(input_dataset, path, shard_func_other_args, scope)`.
pub fn save_dataset<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    input_dataset: O0,
    path: O1,
    shard_func_other_args: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SaveDataset::new().build(input_dataset, path, shard_func_other_args, scope)
}

/// Builder for the `SaveDatasetV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SaveDatasetV2 {
    compression: ::std::option::Option<::std::string::String>,
    shard_func: ::std::option::Option<::std::string::String>,
    use_shard_func: ::std::option::Option<bool>,
    Tshard_func_args: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SaveDatasetV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SaveDatasetV2Inst {
    /// An instance of a fully built SaveDatasetV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SaveDatasetV2 {
    /// Creates a new `SaveDatasetV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `compression` attribute.
    pub fn compression<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.compression = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shard_func` attribute.
    pub fn shard_func<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.shard_func = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_shard_func` attribute.
    pub fn use_shard_func<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.use_shard_func = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tshard_func_args` attribute.
    pub fn Tshard_func_args<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tshard_func_args = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SaveDatasetV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input_dataset: O0,
        path: O1,
        shard_func_other_args: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            input_dataset.into(),
            path.into(),
            shard_func_other_args.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        input_dataset: crate::Output,
        path: crate::Output,
        shard_func_other_args: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SaveDatasetV2", |nd| {
            nd.add_input(input_dataset);
            nd.add_input(path);
            nd.add_input(shard_func_other_args);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.compression {
                nd.set_attr_string("compression", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shard_func {
                nd.set_attr_string("shard_func", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_shard_func {
                nd.set_attr_bool("use_shard_func", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tshard_func_args {
                nd.set_attr_type_list("Tshard_func_args", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SaveDatasetV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_dataset: crate::Output,
        path: crate::Output,
        shard_func_other_args: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SaveDatasetV2Inst> {
        let op = scope.new_operation("SaveDatasetV2", |builder| {
            builder.add_input(input_dataset);
            builder.add_input(path);
            builder.add_input(shard_func_other_args);
            if let ::std::option::Option::Some(value) = &self.compression {
                builder.set_attr_string("compression", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shard_func {
                builder.set_attr_string("shard_func", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_shard_func {
                builder.set_attr_bool("use_shard_func", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tshard_func_args {
                builder.set_attr_type_list("Tshard_func_args", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SaveDatasetV2Inst { op })
    }
}
impl SaveDatasetV2Inst {
    /// Returns the 'handle' Output of this 'SaveDatasetV2' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_dataset' Input of this 'SaveDatasetV2' operation.
    pub fn input_dataset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'path' Input of this 'SaveDatasetV2' operation.
    pub fn path(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'shard_func_other_args' Input of this 'SaveDatasetV2' operation.
    pub fn shard_func_other_args(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<SaveDatasetV2Inst> for crate::Operation {
    fn from(inst: SaveDatasetV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SaveDatasetV2::new().build(input_dataset, path, shard_func_other_args, scope)`.
pub fn save_dataset_v2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    input_dataset: O0,
    path: O1,
    shard_func_other_args: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SaveDatasetV2::new().build(input_dataset, path, shard_func_other_args, scope)
}

/// Builder for the `SaveSlices` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SaveSlices {
    T: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SaveSlices' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SaveSlicesInst {
    /// An instance of a fully built SaveSlices Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SaveSlices {
    /// Creates a new `SaveSlices`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SaveSlices` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
    >(
        &self,
        filename: O0,
        tensor_names: O1,
        shapes_and_slices: O2,
        data: O3,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            filename.into(),
            tensor_names.into(),
            shapes_and_slices.into(),
            data.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        filename: crate::Output,
        tensor_names: crate::Output,
        shapes_and_slices: crate::Output,
        data: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SaveSlices", |nd| {
            nd.add_input(filename);
            nd.add_input(tensor_names);
            nd.add_input(shapes_and_slices);
            nd.add_input(data);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type_list("T", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SaveSlices' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        filename: crate::Output,
        tensor_names: crate::Output,
        shapes_and_slices: crate::Output,
        data: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SaveSlicesInst> {
        let op = scope.new_operation("SaveSlices", |builder| {
            builder.add_input(filename);
            builder.add_input(tensor_names);
            builder.add_input(shapes_and_slices);
            builder.add_input(data);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type_list("T", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SaveSlicesInst { op })
    }
}
impl SaveSlicesInst {
    /// Returns the 'filename' Input of this 'SaveSlices' operation.
    pub fn filename(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'tensor_names' Input of this 'SaveSlices' operation.
    pub fn tensor_names(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'shapes_and_slices' Input of this 'SaveSlices' operation.
    pub fn shapes_and_slices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'data' Input of this 'SaveSlices' operation.
    pub fn data(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
}
impl From<SaveSlicesInst> for crate::Operation {
    fn from(inst: SaveSlicesInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SaveSlices::new().build(filename, tensor_names, shapes_and_slices, data, scope)`.
pub fn save_slices<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
>(
    filename: O0,
    tensor_names: O1,
    shapes_and_slices: O2,
    data: O3,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SaveSlices::new().build(filename, tensor_names, shapes_and_slices, data, scope)
}

/// Builder for the `SaveV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SaveV2 {
    dtypes: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SaveV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SaveV2Inst {
    /// An instance of a fully built SaveV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SaveV2 {
    /// Creates a new `SaveV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `dtypes` attribute.
    pub fn dtypes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.dtypes = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SaveV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
    >(
        &self,
        prefix: O0,
        tensor_names: O1,
        shape_and_slices: O2,
        tensors: O3,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            prefix.into(),
            tensor_names.into(),
            shape_and_slices.into(),
            tensors.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        prefix: crate::Output,
        tensor_names: crate::Output,
        shape_and_slices: crate::Output,
        tensors: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SaveV2", |nd| {
            nd.add_input(prefix);
            nd.add_input(tensor_names);
            nd.add_input(shape_and_slices);
            nd.add_input(tensors);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.dtypes {
                nd.set_attr_type_list("dtypes", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SaveV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        prefix: crate::Output,
        tensor_names: crate::Output,
        shape_and_slices: crate::Output,
        tensors: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SaveV2Inst> {
        let op = scope.new_operation("SaveV2", |builder| {
            builder.add_input(prefix);
            builder.add_input(tensor_names);
            builder.add_input(shape_and_slices);
            builder.add_input(tensors);
            if let ::std::option::Option::Some(value) = &self.dtypes {
                builder.set_attr_type_list("dtypes", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SaveV2Inst { op })
    }
}
impl SaveV2Inst {
    /// Returns the 'prefix' Input of this 'SaveV2' operation.
    pub fn prefix(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'tensor_names' Input of this 'SaveV2' operation.
    pub fn tensor_names(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'shape_and_slices' Input of this 'SaveV2' operation.
    pub fn shape_and_slices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'tensors' Input of this 'SaveV2' operation.
    pub fn tensors(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
}
impl From<SaveV2Inst> for crate::Operation {
    fn from(inst: SaveV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SaveV2::new().build(prefix, tensor_names, shape_and_slices, tensors, scope)`.
pub fn save_v2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
>(
    prefix: O0,
    tensor_names: O1,
    shape_and_slices: O2,
    tensors: O3,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SaveV2::new().build(prefix, tensor_names, shape_and_slices, tensors, scope)
}

/// Builder for the `ScalarSummary` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ScalarSummary {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ScalarSummary' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ScalarSummaryInst {
    /// An instance of a fully built ScalarSummary Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ScalarSummary {
    /// Creates a new `ScalarSummary`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ScalarSummary` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        tags: O0,
        values: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(tags.into(), values.into(), scope)
    }
    fn build_impl(
        &self,
        tags: crate::Output,
        values: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ScalarSummary", |nd| {
            nd.add_input(tags);
            nd.add_input(values);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ScalarSummary' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        tags: crate::Output,
        values: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ScalarSummaryInst> {
        let op = scope.new_operation("ScalarSummary", |builder| {
            builder.add_input(tags);
            builder.add_input(values);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ScalarSummaryInst { op })
    }
}
impl ScalarSummaryInst {
    /// Returns the 'summary' Output of this 'ScalarSummary' operation.
    pub fn summary(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'tags' Input of this 'ScalarSummary' operation.
    pub fn tags(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'values' Input of this 'ScalarSummary' operation.
    pub fn values(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<ScalarSummaryInst> for crate::Operation {
    fn from(inst: ScalarSummaryInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ScalarSummary::new().build(tags, values, scope)`.
pub fn scalar_summary<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    tags: O0,
    values: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ScalarSummary::new().build(tags, values, scope)
}

/// Builder for the `ScaleAndTranslate` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ScaleAndTranslate {
    T: ::std::option::Option<crate::DataType>,
    kernel_type: ::std::option::Option<::std::string::String>,
    antialias: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ScaleAndTranslate' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ScaleAndTranslateInst {
    /// An instance of a fully built ScaleAndTranslate Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ScaleAndTranslate {
    /// Creates a new `ScaleAndTranslate`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `kernel_type` attribute.
    pub fn kernel_type<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.kernel_type = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `antialias` attribute.
    pub fn antialias<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.antialias = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ScaleAndTranslate` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
    >(
        &self,
        images: O0,
        size: O1,
        scale: O2,
        translation: O3,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            images.into(),
            size.into(),
            scale.into(),
            translation.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        images: crate::Output,
        size: crate::Output,
        scale: crate::Output,
        translation: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ScaleAndTranslate", |nd| {
            nd.add_input(images);
            nd.add_input(size);
            nd.add_input(scale);
            nd.add_input(translation);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.kernel_type {
                nd.set_attr_string("kernel_type", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.antialias {
                nd.set_attr_bool("antialias", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ScaleAndTranslate' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        images: crate::Output,
        size: crate::Output,
        scale: crate::Output,
        translation: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ScaleAndTranslateInst> {
        let op = scope.new_operation("ScaleAndTranslate", |builder| {
            builder.add_input(images);
            builder.add_input(size);
            builder.add_input(scale);
            builder.add_input(translation);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.kernel_type {
                builder.set_attr_string("kernel_type", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.antialias {
                builder.set_attr_bool("antialias", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ScaleAndTranslateInst { op })
    }
}
impl ScaleAndTranslateInst {
    /// Returns the 'resized_images' Output of this 'ScaleAndTranslate' operation.
    pub fn resized_images(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'images' Input of this 'ScaleAndTranslate' operation.
    pub fn images(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'size' Input of this 'ScaleAndTranslate' operation.
    pub fn size(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'scale' Input of this 'ScaleAndTranslate' operation.
    pub fn scale(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'translation' Input of this 'ScaleAndTranslate' operation.
    pub fn translation(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
}
impl From<ScaleAndTranslateInst> for crate::Operation {
    fn from(inst: ScaleAndTranslateInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ScaleAndTranslate::new().build(images, size, scale, translation, scope)`.
pub fn scale_and_translate<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
>(
    images: O0,
    size: O1,
    scale: O2,
    translation: O3,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ScaleAndTranslate::new().build(images, size, scale, translation, scope)
}

/// Builder for the `ScaleAndTranslateGrad` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ScaleAndTranslateGrad {
    T: ::std::option::Option<crate::DataType>,
    kernel_type: ::std::option::Option<::std::string::String>,
    antialias: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ScaleAndTranslateGrad' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ScaleAndTranslateGradInst {
    /// An instance of a fully built ScaleAndTranslateGrad Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ScaleAndTranslateGrad {
    /// Creates a new `ScaleAndTranslateGrad`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `kernel_type` attribute.
    pub fn kernel_type<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.kernel_type = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `antialias` attribute.
    pub fn antialias<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.antialias = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ScaleAndTranslateGrad` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
    >(
        &self,
        grads: O0,
        original_image: O1,
        scale: O2,
        translation: O3,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            grads.into(),
            original_image.into(),
            scale.into(),
            translation.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        grads: crate::Output,
        original_image: crate::Output,
        scale: crate::Output,
        translation: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ScaleAndTranslateGrad", |nd| {
            nd.add_input(grads);
            nd.add_input(original_image);
            nd.add_input(scale);
            nd.add_input(translation);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.kernel_type {
                nd.set_attr_string("kernel_type", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.antialias {
                nd.set_attr_bool("antialias", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ScaleAndTranslateGrad' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        grads: crate::Output,
        original_image: crate::Output,
        scale: crate::Output,
        translation: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ScaleAndTranslateGradInst> {
        let op = scope.new_operation("ScaleAndTranslateGrad", |builder| {
            builder.add_input(grads);
            builder.add_input(original_image);
            builder.add_input(scale);
            builder.add_input(translation);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.kernel_type {
                builder.set_attr_string("kernel_type", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.antialias {
                builder.set_attr_bool("antialias", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ScaleAndTranslateGradInst { op })
    }
}
impl ScaleAndTranslateGradInst {
    /// Returns the 'output' Output of this 'ScaleAndTranslateGrad' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'grads' Input of this 'ScaleAndTranslateGrad' operation.
    pub fn grads(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'original_image' Input of this 'ScaleAndTranslateGrad' operation.
    pub fn original_image(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'scale' Input of this 'ScaleAndTranslateGrad' operation.
    pub fn scale(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'translation' Input of this 'ScaleAndTranslateGrad' operation.
    pub fn translation(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
}
impl From<ScaleAndTranslateGradInst> for crate::Operation {
    fn from(inst: ScaleAndTranslateGradInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ScaleAndTranslateGrad::new().build(grads, original_image, scale, translation, scope)`.
pub fn scale_and_translate_grad<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
>(
    grads: O0,
    original_image: O1,
    scale: O2,
    translation: O3,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ScaleAndTranslateGrad::new().build(grads, original_image, scale, translation, scope)
}

/// Builder for the `ScanDataset` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ScanDataset {
    f: ::std::option::Option<::std::string::String>,
    Tstate: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    Targuments: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    preserve_cardinality: ::std::option::Option<bool>,
    use_default_device: ::std::option::Option<bool>,
    metadata: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ScanDataset' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ScanDatasetInst {
    /// An instance of a fully built ScanDataset Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ScanDataset {
    /// Creates a new `ScanDataset`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `f` attribute.
    pub fn f<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.f = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tstate` attribute.
    pub fn Tstate<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tstate = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Targuments` attribute.
    pub fn Targuments<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Targuments = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `preserve_cardinality` attribute.
    pub fn preserve_cardinality<ArgType: ::std::convert::Into<bool>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.preserve_cardinality = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_default_device` attribute.
    pub fn use_default_device<ArgType: ::std::convert::Into<bool>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.use_default_device = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `metadata` attribute.
    pub fn metadata<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.metadata = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ScanDataset` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input_dataset: O0,
        initial_state: O1,
        other_arguments: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            input_dataset.into(),
            initial_state.into(),
            other_arguments.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        input_dataset: crate::Output,
        initial_state: crate::Output,
        other_arguments: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ScanDataset", |nd| {
            nd.add_input(input_dataset);
            nd.add_input(initial_state);
            nd.add_input(other_arguments);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.f {
                nd.set_attr_string("f", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tstate {
                nd.set_attr_type_list("Tstate", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Targuments {
                nd.set_attr_type_list("Targuments", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.preserve_cardinality {
                nd.set_attr_bool("preserve_cardinality", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_default_device {
                nd.set_attr_bool("use_default_device", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.metadata {
                nd.set_attr_string("metadata", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ScanDataset' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_dataset: crate::Output,
        initial_state: crate::Output,
        other_arguments: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ScanDatasetInst> {
        let op = scope.new_operation("ScanDataset", |builder| {
            builder.add_input(input_dataset);
            builder.add_input(initial_state);
            builder.add_input(other_arguments);
            if let ::std::option::Option::Some(value) = &self.f {
                builder.set_attr_string("f", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tstate {
                builder.set_attr_type_list("Tstate", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Targuments {
                builder.set_attr_type_list("Targuments", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.preserve_cardinality {
                builder.set_attr_bool("preserve_cardinality", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_default_device {
                builder.set_attr_bool("use_default_device", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.metadata {
                builder.set_attr_string("metadata", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ScanDatasetInst { op })
    }
}
impl ScanDatasetInst {
    /// Returns the 'handle' Output of this 'ScanDataset' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_dataset' Input of this 'ScanDataset' operation.
    pub fn input_dataset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'initial_state' Input of this 'ScanDataset' operation.
    pub fn initial_state(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'other_arguments' Input of this 'ScanDataset' operation.
    pub fn other_arguments(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<ScanDatasetInst> for crate::Operation {
    fn from(inst: ScanDatasetInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ScanDataset::new().build(input_dataset, initial_state, other_arguments, scope)`.
pub fn scan_dataset<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    input_dataset: O0,
    initial_state: O1,
    other_arguments: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ScanDataset::new().build(input_dataset, initial_state, other_arguments, scope)
}

/// Builder for the `ScatterAdd` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ScatterAdd {
    T: ::std::option::Option<crate::DataType>,
    Tindices: ::std::option::Option<crate::DataType>,
    use_locking: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ScatterAdd' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ScatterAddInst {
    /// An instance of a fully built ScatterAdd Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ScatterAdd {
    /// Creates a new `ScatterAdd`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tindices` attribute.
    pub fn Tindices<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tindices = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_locking` attribute.
    pub fn use_locking<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.use_locking = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ScatterAdd` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        ref_: O0,
        indices: O1,
        updates: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(ref_.into(), indices.into(), updates.into(), scope)
    }
    fn build_impl(
        &self,
        ref_: crate::Output,
        indices: crate::Output,
        updates: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ScatterAdd", |nd| {
            nd.add_input(ref_);
            nd.add_input(indices);
            nd.add_input(updates);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                nd.set_attr_type("Tindices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                nd.set_attr_bool("use_locking", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ScatterAdd' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        ref_: crate::Output,
        indices: crate::Output,
        updates: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ScatterAddInst> {
        let op = scope.new_operation("ScatterAdd", |builder| {
            builder.add_input(ref_);
            builder.add_input(indices);
            builder.add_input(updates);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                builder.set_attr_type("Tindices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                builder.set_attr_bool("use_locking", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ScatterAddInst { op })
    }
}
impl ScatterAddInst {
    /// Returns the 'output_ref' Output of this 'ScatterAdd' operation.
    pub fn output_ref(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'ref_' Input of this 'ScatterAdd' operation.
    pub fn ref_(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'indices' Input of this 'ScatterAdd' operation.
    pub fn indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'updates' Input of this 'ScatterAdd' operation.
    pub fn updates(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<ScatterAddInst> for crate::Operation {
    fn from(inst: ScatterAddInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ScatterAdd::new().build(ref_, indices, updates, scope)`.
pub fn scatter_add<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    ref_: O0,
    indices: O1,
    updates: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ScatterAdd::new().build(ref_, indices, updates, scope)
}

/// Builder for the `ScatterDiv` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ScatterDiv {
    T: ::std::option::Option<crate::DataType>,
    Tindices: ::std::option::Option<crate::DataType>,
    use_locking: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ScatterDiv' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ScatterDivInst {
    /// An instance of a fully built ScatterDiv Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ScatterDiv {
    /// Creates a new `ScatterDiv`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tindices` attribute.
    pub fn Tindices<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tindices = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_locking` attribute.
    pub fn use_locking<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.use_locking = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ScatterDiv` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        ref_: O0,
        indices: O1,
        updates: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(ref_.into(), indices.into(), updates.into(), scope)
    }
    fn build_impl(
        &self,
        ref_: crate::Output,
        indices: crate::Output,
        updates: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ScatterDiv", |nd| {
            nd.add_input(ref_);
            nd.add_input(indices);
            nd.add_input(updates);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                nd.set_attr_type("Tindices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                nd.set_attr_bool("use_locking", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ScatterDiv' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        ref_: crate::Output,
        indices: crate::Output,
        updates: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ScatterDivInst> {
        let op = scope.new_operation("ScatterDiv", |builder| {
            builder.add_input(ref_);
            builder.add_input(indices);
            builder.add_input(updates);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                builder.set_attr_type("Tindices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                builder.set_attr_bool("use_locking", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ScatterDivInst { op })
    }
}
impl ScatterDivInst {
    /// Returns the 'output_ref' Output of this 'ScatterDiv' operation.
    pub fn output_ref(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'ref_' Input of this 'ScatterDiv' operation.
    pub fn ref_(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'indices' Input of this 'ScatterDiv' operation.
    pub fn indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'updates' Input of this 'ScatterDiv' operation.
    pub fn updates(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<ScatterDivInst> for crate::Operation {
    fn from(inst: ScatterDivInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ScatterDiv::new().build(ref_, indices, updates, scope)`.
pub fn scatter_div<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    ref_: O0,
    indices: O1,
    updates: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ScatterDiv::new().build(ref_, indices, updates, scope)
}

/// Builder for the `ScatterMax` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ScatterMax {
    T: ::std::option::Option<crate::DataType>,
    Tindices: ::std::option::Option<crate::DataType>,
    use_locking: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ScatterMax' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ScatterMaxInst {
    /// An instance of a fully built ScatterMax Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ScatterMax {
    /// Creates a new `ScatterMax`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tindices` attribute.
    pub fn Tindices<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tindices = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_locking` attribute.
    pub fn use_locking<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.use_locking = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ScatterMax` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        ref_: O0,
        indices: O1,
        updates: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(ref_.into(), indices.into(), updates.into(), scope)
    }
    fn build_impl(
        &self,
        ref_: crate::Output,
        indices: crate::Output,
        updates: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ScatterMax", |nd| {
            nd.add_input(ref_);
            nd.add_input(indices);
            nd.add_input(updates);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                nd.set_attr_type("Tindices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                nd.set_attr_bool("use_locking", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ScatterMax' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        ref_: crate::Output,
        indices: crate::Output,
        updates: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ScatterMaxInst> {
        let op = scope.new_operation("ScatterMax", |builder| {
            builder.add_input(ref_);
            builder.add_input(indices);
            builder.add_input(updates);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                builder.set_attr_type("Tindices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                builder.set_attr_bool("use_locking", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ScatterMaxInst { op })
    }
}
impl ScatterMaxInst {
    /// Returns the 'output_ref' Output of this 'ScatterMax' operation.
    pub fn output_ref(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'ref_' Input of this 'ScatterMax' operation.
    pub fn ref_(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'indices' Input of this 'ScatterMax' operation.
    pub fn indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'updates' Input of this 'ScatterMax' operation.
    pub fn updates(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<ScatterMaxInst> for crate::Operation {
    fn from(inst: ScatterMaxInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ScatterMax::new().build(ref_, indices, updates, scope)`.
pub fn scatter_max<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    ref_: O0,
    indices: O1,
    updates: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ScatterMax::new().build(ref_, indices, updates, scope)
}

/// Builder for the `ScatterMin` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ScatterMin {
    T: ::std::option::Option<crate::DataType>,
    Tindices: ::std::option::Option<crate::DataType>,
    use_locking: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ScatterMin' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ScatterMinInst {
    /// An instance of a fully built ScatterMin Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ScatterMin {
    /// Creates a new `ScatterMin`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tindices` attribute.
    pub fn Tindices<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tindices = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_locking` attribute.
    pub fn use_locking<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.use_locking = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ScatterMin` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        ref_: O0,
        indices: O1,
        updates: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(ref_.into(), indices.into(), updates.into(), scope)
    }
    fn build_impl(
        &self,
        ref_: crate::Output,
        indices: crate::Output,
        updates: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ScatterMin", |nd| {
            nd.add_input(ref_);
            nd.add_input(indices);
            nd.add_input(updates);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                nd.set_attr_type("Tindices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                nd.set_attr_bool("use_locking", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ScatterMin' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        ref_: crate::Output,
        indices: crate::Output,
        updates: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ScatterMinInst> {
        let op = scope.new_operation("ScatterMin", |builder| {
            builder.add_input(ref_);
            builder.add_input(indices);
            builder.add_input(updates);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                builder.set_attr_type("Tindices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                builder.set_attr_bool("use_locking", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ScatterMinInst { op })
    }
}
impl ScatterMinInst {
    /// Returns the 'output_ref' Output of this 'ScatterMin' operation.
    pub fn output_ref(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'ref_' Input of this 'ScatterMin' operation.
    pub fn ref_(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'indices' Input of this 'ScatterMin' operation.
    pub fn indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'updates' Input of this 'ScatterMin' operation.
    pub fn updates(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<ScatterMinInst> for crate::Operation {
    fn from(inst: ScatterMinInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ScatterMin::new().build(ref_, indices, updates, scope)`.
pub fn scatter_min<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    ref_: O0,
    indices: O1,
    updates: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ScatterMin::new().build(ref_, indices, updates, scope)
}

/// Builder for the `ScatterMul` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ScatterMul {
    T: ::std::option::Option<crate::DataType>,
    Tindices: ::std::option::Option<crate::DataType>,
    use_locking: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ScatterMul' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ScatterMulInst {
    /// An instance of a fully built ScatterMul Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ScatterMul {
    /// Creates a new `ScatterMul`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tindices` attribute.
    pub fn Tindices<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tindices = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_locking` attribute.
    pub fn use_locking<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.use_locking = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ScatterMul` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        ref_: O0,
        indices: O1,
        updates: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(ref_.into(), indices.into(), updates.into(), scope)
    }
    fn build_impl(
        &self,
        ref_: crate::Output,
        indices: crate::Output,
        updates: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ScatterMul", |nd| {
            nd.add_input(ref_);
            nd.add_input(indices);
            nd.add_input(updates);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                nd.set_attr_type("Tindices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                nd.set_attr_bool("use_locking", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ScatterMul' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        ref_: crate::Output,
        indices: crate::Output,
        updates: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ScatterMulInst> {
        let op = scope.new_operation("ScatterMul", |builder| {
            builder.add_input(ref_);
            builder.add_input(indices);
            builder.add_input(updates);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                builder.set_attr_type("Tindices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                builder.set_attr_bool("use_locking", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ScatterMulInst { op })
    }
}
impl ScatterMulInst {
    /// Returns the 'output_ref' Output of this 'ScatterMul' operation.
    pub fn output_ref(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'ref_' Input of this 'ScatterMul' operation.
    pub fn ref_(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'indices' Input of this 'ScatterMul' operation.
    pub fn indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'updates' Input of this 'ScatterMul' operation.
    pub fn updates(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<ScatterMulInst> for crate::Operation {
    fn from(inst: ScatterMulInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ScatterMul::new().build(ref_, indices, updates, scope)`.
pub fn scatter_mul<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    ref_: O0,
    indices: O1,
    updates: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ScatterMul::new().build(ref_, indices, updates, scope)
}

/// Builder for the `ScatterNd` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ScatterNd {
    T: ::std::option::Option<crate::DataType>,
    Tindices: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ScatterNd' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ScatterNdInst {
    /// An instance of a fully built ScatterNd Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ScatterNd {
    /// Creates a new `ScatterNd`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tindices` attribute.
    pub fn Tindices<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tindices = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ScatterNd` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        indices: O0,
        updates: O1,
        shape: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(indices.into(), updates.into(), shape.into(), scope)
    }
    fn build_impl(
        &self,
        indices: crate::Output,
        updates: crate::Output,
        shape: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ScatterNd", |nd| {
            nd.add_input(indices);
            nd.add_input(updates);
            nd.add_input(shape);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                nd.set_attr_type("Tindices", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ScatterNd' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        indices: crate::Output,
        updates: crate::Output,
        shape: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ScatterNdInst> {
        let op = scope.new_operation("ScatterNd", |builder| {
            builder.add_input(indices);
            builder.add_input(updates);
            builder.add_input(shape);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                builder.set_attr_type("Tindices", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ScatterNdInst { op })
    }
}
impl ScatterNdInst {
    /// Returns the 'output' Output of this 'ScatterNd' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'indices' Input of this 'ScatterNd' operation.
    pub fn indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'updates' Input of this 'ScatterNd' operation.
    pub fn updates(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'shape' Input of this 'ScatterNd' operation.
    pub fn shape(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<ScatterNdInst> for crate::Operation {
    fn from(inst: ScatterNdInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ScatterNd::new().build(indices, updates, shape, scope)`.
pub fn scatter_nd<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    indices: O0,
    updates: O1,
    shape: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ScatterNd::new().build(indices, updates, shape, scope)
}

/// Builder for the `ScatterNdAdd` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ScatterNdAdd {
    T: ::std::option::Option<crate::DataType>,
    Tindices: ::std::option::Option<crate::DataType>,
    use_locking: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ScatterNdAdd' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ScatterNdAddInst {
    /// An instance of a fully built ScatterNdAdd Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ScatterNdAdd {
    /// Creates a new `ScatterNdAdd`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tindices` attribute.
    pub fn Tindices<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tindices = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_locking` attribute.
    pub fn use_locking<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.use_locking = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ScatterNdAdd` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        ref_: O0,
        indices: O1,
        updates: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(ref_.into(), indices.into(), updates.into(), scope)
    }
    fn build_impl(
        &self,
        ref_: crate::Output,
        indices: crate::Output,
        updates: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ScatterNdAdd", |nd| {
            nd.add_input(ref_);
            nd.add_input(indices);
            nd.add_input(updates);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                nd.set_attr_type("Tindices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                nd.set_attr_bool("use_locking", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ScatterNdAdd' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        ref_: crate::Output,
        indices: crate::Output,
        updates: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ScatterNdAddInst> {
        let op = scope.new_operation("ScatterNdAdd", |builder| {
            builder.add_input(ref_);
            builder.add_input(indices);
            builder.add_input(updates);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                builder.set_attr_type("Tindices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                builder.set_attr_bool("use_locking", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ScatterNdAddInst { op })
    }
}
impl ScatterNdAddInst {
    /// Returns the 'output_ref' Output of this 'ScatterNdAdd' operation.
    pub fn output_ref(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'ref_' Input of this 'ScatterNdAdd' operation.
    pub fn ref_(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'indices' Input of this 'ScatterNdAdd' operation.
    pub fn indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'updates' Input of this 'ScatterNdAdd' operation.
    pub fn updates(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<ScatterNdAddInst> for crate::Operation {
    fn from(inst: ScatterNdAddInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ScatterNdAdd::new().build(ref_, indices, updates, scope)`.
pub fn scatter_nd_add<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    ref_: O0,
    indices: O1,
    updates: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ScatterNdAdd::new().build(ref_, indices, updates, scope)
}

/// Builder for the `ScatterNdMax` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ScatterNdMax {
    T: ::std::option::Option<crate::DataType>,
    Tindices: ::std::option::Option<crate::DataType>,
    use_locking: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ScatterNdMax' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ScatterNdMaxInst {
    /// An instance of a fully built ScatterNdMax Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ScatterNdMax {
    /// Creates a new `ScatterNdMax`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tindices` attribute.
    pub fn Tindices<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tindices = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_locking` attribute.
    pub fn use_locking<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.use_locking = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ScatterNdMax` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        ref_: O0,
        indices: O1,
        updates: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(ref_.into(), indices.into(), updates.into(), scope)
    }
    fn build_impl(
        &self,
        ref_: crate::Output,
        indices: crate::Output,
        updates: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ScatterNdMax", |nd| {
            nd.add_input(ref_);
            nd.add_input(indices);
            nd.add_input(updates);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                nd.set_attr_type("Tindices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                nd.set_attr_bool("use_locking", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ScatterNdMax' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        ref_: crate::Output,
        indices: crate::Output,
        updates: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ScatterNdMaxInst> {
        let op = scope.new_operation("ScatterNdMax", |builder| {
            builder.add_input(ref_);
            builder.add_input(indices);
            builder.add_input(updates);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                builder.set_attr_type("Tindices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                builder.set_attr_bool("use_locking", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ScatterNdMaxInst { op })
    }
}
impl ScatterNdMaxInst {
    /// Returns the 'output_ref' Output of this 'ScatterNdMax' operation.
    pub fn output_ref(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'ref_' Input of this 'ScatterNdMax' operation.
    pub fn ref_(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'indices' Input of this 'ScatterNdMax' operation.
    pub fn indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'updates' Input of this 'ScatterNdMax' operation.
    pub fn updates(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<ScatterNdMaxInst> for crate::Operation {
    fn from(inst: ScatterNdMaxInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ScatterNdMax::new().build(ref_, indices, updates, scope)`.
pub fn scatter_nd_max<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    ref_: O0,
    indices: O1,
    updates: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ScatterNdMax::new().build(ref_, indices, updates, scope)
}

/// Builder for the `ScatterNdMin` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ScatterNdMin {
    T: ::std::option::Option<crate::DataType>,
    Tindices: ::std::option::Option<crate::DataType>,
    use_locking: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ScatterNdMin' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ScatterNdMinInst {
    /// An instance of a fully built ScatterNdMin Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ScatterNdMin {
    /// Creates a new `ScatterNdMin`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tindices` attribute.
    pub fn Tindices<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tindices = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_locking` attribute.
    pub fn use_locking<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.use_locking = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ScatterNdMin` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        ref_: O0,
        indices: O1,
        updates: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(ref_.into(), indices.into(), updates.into(), scope)
    }
    fn build_impl(
        &self,
        ref_: crate::Output,
        indices: crate::Output,
        updates: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ScatterNdMin", |nd| {
            nd.add_input(ref_);
            nd.add_input(indices);
            nd.add_input(updates);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                nd.set_attr_type("Tindices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                nd.set_attr_bool("use_locking", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ScatterNdMin' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        ref_: crate::Output,
        indices: crate::Output,
        updates: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ScatterNdMinInst> {
        let op = scope.new_operation("ScatterNdMin", |builder| {
            builder.add_input(ref_);
            builder.add_input(indices);
            builder.add_input(updates);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                builder.set_attr_type("Tindices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                builder.set_attr_bool("use_locking", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ScatterNdMinInst { op })
    }
}
impl ScatterNdMinInst {
    /// Returns the 'output_ref' Output of this 'ScatterNdMin' operation.
    pub fn output_ref(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'ref_' Input of this 'ScatterNdMin' operation.
    pub fn ref_(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'indices' Input of this 'ScatterNdMin' operation.
    pub fn indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'updates' Input of this 'ScatterNdMin' operation.
    pub fn updates(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<ScatterNdMinInst> for crate::Operation {
    fn from(inst: ScatterNdMinInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ScatterNdMin::new().build(ref_, indices, updates, scope)`.
pub fn scatter_nd_min<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    ref_: O0,
    indices: O1,
    updates: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ScatterNdMin::new().build(ref_, indices, updates, scope)
}

/// Builder for the `ScatterNdNonAliasingAdd` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ScatterNdNonAliasingAdd {
    T: ::std::option::Option<crate::DataType>,
    Tindices: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ScatterNdNonAliasingAdd' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ScatterNdNonAliasingAddInst {
    /// An instance of a fully built ScatterNdNonAliasingAdd Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ScatterNdNonAliasingAdd {
    /// Creates a new `ScatterNdNonAliasingAdd`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tindices` attribute.
    pub fn Tindices<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tindices = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ScatterNdNonAliasingAdd` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        indices: O1,
        updates: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), indices.into(), updates.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        indices: crate::Output,
        updates: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ScatterNdNonAliasingAdd", |nd| {
            nd.add_input(input);
            nd.add_input(indices);
            nd.add_input(updates);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                nd.set_attr_type("Tindices", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ScatterNdNonAliasingAdd' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        indices: crate::Output,
        updates: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ScatterNdNonAliasingAddInst> {
        let op = scope.new_operation("ScatterNdNonAliasingAdd", |builder| {
            builder.add_input(input);
            builder.add_input(indices);
            builder.add_input(updates);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                builder.set_attr_type("Tindices", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ScatterNdNonAliasingAddInst { op })
    }
}
impl ScatterNdNonAliasingAddInst {
    /// Returns the 'output' Output of this 'ScatterNdNonAliasingAdd' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'ScatterNdNonAliasingAdd' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'indices' Input of this 'ScatterNdNonAliasingAdd' operation.
    pub fn indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'updates' Input of this 'ScatterNdNonAliasingAdd' operation.
    pub fn updates(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<ScatterNdNonAliasingAddInst> for crate::Operation {
    fn from(inst: ScatterNdNonAliasingAddInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ScatterNdNonAliasingAdd::new().build(input, indices, updates, scope)`.
pub fn scatter_nd_non_aliasing_add<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    input: O0,
    indices: O1,
    updates: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ScatterNdNonAliasingAdd::new().build(input, indices, updates, scope)
}

/// Builder for the `ScatterNdSub` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ScatterNdSub {
    T: ::std::option::Option<crate::DataType>,
    Tindices: ::std::option::Option<crate::DataType>,
    use_locking: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ScatterNdSub' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ScatterNdSubInst {
    /// An instance of a fully built ScatterNdSub Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ScatterNdSub {
    /// Creates a new `ScatterNdSub`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tindices` attribute.
    pub fn Tindices<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tindices = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_locking` attribute.
    pub fn use_locking<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.use_locking = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ScatterNdSub` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        ref_: O0,
        indices: O1,
        updates: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(ref_.into(), indices.into(), updates.into(), scope)
    }
    fn build_impl(
        &self,
        ref_: crate::Output,
        indices: crate::Output,
        updates: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ScatterNdSub", |nd| {
            nd.add_input(ref_);
            nd.add_input(indices);
            nd.add_input(updates);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                nd.set_attr_type("Tindices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                nd.set_attr_bool("use_locking", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ScatterNdSub' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        ref_: crate::Output,
        indices: crate::Output,
        updates: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ScatterNdSubInst> {
        let op = scope.new_operation("ScatterNdSub", |builder| {
            builder.add_input(ref_);
            builder.add_input(indices);
            builder.add_input(updates);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                builder.set_attr_type("Tindices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                builder.set_attr_bool("use_locking", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ScatterNdSubInst { op })
    }
}
impl ScatterNdSubInst {
    /// Returns the 'output_ref' Output of this 'ScatterNdSub' operation.
    pub fn output_ref(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'ref_' Input of this 'ScatterNdSub' operation.
    pub fn ref_(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'indices' Input of this 'ScatterNdSub' operation.
    pub fn indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'updates' Input of this 'ScatterNdSub' operation.
    pub fn updates(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<ScatterNdSubInst> for crate::Operation {
    fn from(inst: ScatterNdSubInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ScatterNdSub::new().build(ref_, indices, updates, scope)`.
pub fn scatter_nd_sub<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    ref_: O0,
    indices: O1,
    updates: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ScatterNdSub::new().build(ref_, indices, updates, scope)
}

/// Builder for the `ScatterNdUpdate` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ScatterNdUpdate {
    T: ::std::option::Option<crate::DataType>,
    Tindices: ::std::option::Option<crate::DataType>,
    use_locking: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ScatterNdUpdate' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ScatterNdUpdateInst {
    /// An instance of a fully built ScatterNdUpdate Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ScatterNdUpdate {
    /// Creates a new `ScatterNdUpdate`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tindices` attribute.
    pub fn Tindices<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tindices = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_locking` attribute.
    pub fn use_locking<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.use_locking = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ScatterNdUpdate` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        ref_: O0,
        indices: O1,
        updates: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(ref_.into(), indices.into(), updates.into(), scope)
    }
    fn build_impl(
        &self,
        ref_: crate::Output,
        indices: crate::Output,
        updates: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ScatterNdUpdate", |nd| {
            nd.add_input(ref_);
            nd.add_input(indices);
            nd.add_input(updates);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                nd.set_attr_type("Tindices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                nd.set_attr_bool("use_locking", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ScatterNdUpdate' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        ref_: crate::Output,
        indices: crate::Output,
        updates: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ScatterNdUpdateInst> {
        let op = scope.new_operation("ScatterNdUpdate", |builder| {
            builder.add_input(ref_);
            builder.add_input(indices);
            builder.add_input(updates);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                builder.set_attr_type("Tindices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                builder.set_attr_bool("use_locking", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ScatterNdUpdateInst { op })
    }
}
impl ScatterNdUpdateInst {
    /// Returns the 'output_ref' Output of this 'ScatterNdUpdate' operation.
    pub fn output_ref(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'ref_' Input of this 'ScatterNdUpdate' operation.
    pub fn ref_(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'indices' Input of this 'ScatterNdUpdate' operation.
    pub fn indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'updates' Input of this 'ScatterNdUpdate' operation.
    pub fn updates(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<ScatterNdUpdateInst> for crate::Operation {
    fn from(inst: ScatterNdUpdateInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ScatterNdUpdate::new().build(ref_, indices, updates, scope)`.
pub fn scatter_nd_update<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    ref_: O0,
    indices: O1,
    updates: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ScatterNdUpdate::new().build(ref_, indices, updates, scope)
}

/// Builder for the `ScatterSub` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ScatterSub {
    T: ::std::option::Option<crate::DataType>,
    Tindices: ::std::option::Option<crate::DataType>,
    use_locking: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ScatterSub' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ScatterSubInst {
    /// An instance of a fully built ScatterSub Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ScatterSub {
    /// Creates a new `ScatterSub`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tindices` attribute.
    pub fn Tindices<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tindices = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_locking` attribute.
    pub fn use_locking<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.use_locking = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ScatterSub` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        ref_: O0,
        indices: O1,
        updates: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(ref_.into(), indices.into(), updates.into(), scope)
    }
    fn build_impl(
        &self,
        ref_: crate::Output,
        indices: crate::Output,
        updates: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ScatterSub", |nd| {
            nd.add_input(ref_);
            nd.add_input(indices);
            nd.add_input(updates);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                nd.set_attr_type("Tindices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                nd.set_attr_bool("use_locking", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ScatterSub' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        ref_: crate::Output,
        indices: crate::Output,
        updates: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ScatterSubInst> {
        let op = scope.new_operation("ScatterSub", |builder| {
            builder.add_input(ref_);
            builder.add_input(indices);
            builder.add_input(updates);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                builder.set_attr_type("Tindices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                builder.set_attr_bool("use_locking", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ScatterSubInst { op })
    }
}
impl ScatterSubInst {
    /// Returns the 'output_ref' Output of this 'ScatterSub' operation.
    pub fn output_ref(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'ref_' Input of this 'ScatterSub' operation.
    pub fn ref_(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'indices' Input of this 'ScatterSub' operation.
    pub fn indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'updates' Input of this 'ScatterSub' operation.
    pub fn updates(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<ScatterSubInst> for crate::Operation {
    fn from(inst: ScatterSubInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ScatterSub::new().build(ref_, indices, updates, scope)`.
pub fn scatter_sub<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    ref_: O0,
    indices: O1,
    updates: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ScatterSub::new().build(ref_, indices, updates, scope)
}

/// Builder for the `ScatterUpdate` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ScatterUpdate {
    T: ::std::option::Option<crate::DataType>,
    Tindices: ::std::option::Option<crate::DataType>,
    use_locking: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ScatterUpdate' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ScatterUpdateInst {
    /// An instance of a fully built ScatterUpdate Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ScatterUpdate {
    /// Creates a new `ScatterUpdate`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tindices` attribute.
    pub fn Tindices<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tindices = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_locking` attribute.
    pub fn use_locking<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.use_locking = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ScatterUpdate` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        ref_: O0,
        indices: O1,
        updates: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(ref_.into(), indices.into(), updates.into(), scope)
    }
    fn build_impl(
        &self,
        ref_: crate::Output,
        indices: crate::Output,
        updates: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ScatterUpdate", |nd| {
            nd.add_input(ref_);
            nd.add_input(indices);
            nd.add_input(updates);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                nd.set_attr_type("Tindices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                nd.set_attr_bool("use_locking", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ScatterUpdate' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        ref_: crate::Output,
        indices: crate::Output,
        updates: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ScatterUpdateInst> {
        let op = scope.new_operation("ScatterUpdate", |builder| {
            builder.add_input(ref_);
            builder.add_input(indices);
            builder.add_input(updates);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                builder.set_attr_type("Tindices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                builder.set_attr_bool("use_locking", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ScatterUpdateInst { op })
    }
}
impl ScatterUpdateInst {
    /// Returns the 'output_ref' Output of this 'ScatterUpdate' operation.
    pub fn output_ref(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'ref_' Input of this 'ScatterUpdate' operation.
    pub fn ref_(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'indices' Input of this 'ScatterUpdate' operation.
    pub fn indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'updates' Input of this 'ScatterUpdate' operation.
    pub fn updates(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<ScatterUpdateInst> for crate::Operation {
    fn from(inst: ScatterUpdateInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ScatterUpdate::new().build(ref_, indices, updates, scope)`.
pub fn scatter_update<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    ref_: O0,
    indices: O1,
    updates: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ScatterUpdate::new().build(ref_, indices, updates, scope)
}

/// Builder for the `SdcaFprint` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SdcaFprint {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SdcaFprint' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SdcaFprintInst {
    /// An instance of a fully built SdcaFprint Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SdcaFprint {
    /// Creates a new `SdcaFprint`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SdcaFprint` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SdcaFprint", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SdcaFprint' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SdcaFprintInst> {
        let op = scope.new_operation("SdcaFprint", |builder| {
            builder.add_input(input);
            ::std::result::Result::Ok(())
        })?;
        Ok(SdcaFprintInst { op })
    }
}
impl SdcaFprintInst {
    /// Returns the 'output' Output of this 'SdcaFprint' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'SdcaFprint' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<SdcaFprintInst> for crate::Operation {
    fn from(inst: SdcaFprintInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SdcaFprint::new().build(input, scope)`.
pub fn sdca_fprint<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SdcaFprint::new().build(input, scope)
}

/// Builder for the `SdcaOptimizer` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SdcaOptimizer {
    loss_type: ::std::option::Option<::std::string::String>,
    adaptative: ::std::option::Option<bool>,
    num_sparse_features: ::std::option::Option<i64>,
    num_sparse_features_with_values: ::std::option::Option<i64>,
    num_dense_features: ::std::option::Option<i64>,
    l1: ::std::option::Option<f32>,
    l2: ::std::option::Option<f32>,
    num_loss_partitions: ::std::option::Option<i64>,
    num_inner_iterations: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SdcaOptimizer' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SdcaOptimizerInst {
    /// An instance of a fully built SdcaOptimizer Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SdcaOptimizer {
    /// Creates a new `SdcaOptimizer`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `loss_type` attribute.
    pub fn loss_type<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.loss_type = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `adaptative` attribute.
    pub fn adaptative<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.adaptative = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `num_sparse_features` attribute.
    pub fn num_sparse_features<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.num_sparse_features = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `num_sparse_features_with_values` attribute.
    pub fn num_sparse_features_with_values<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.num_sparse_features_with_values = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `num_dense_features` attribute.
    pub fn num_dense_features<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.num_dense_features = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `l1` attribute.
    pub fn l1<ArgType: ::std::convert::Into<f32>>(mut self, value: ArgType) -> Self {
        self.l1 = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `l2` attribute.
    pub fn l2<ArgType: ::std::convert::Into<f32>>(mut self, value: ArgType) -> Self {
        self.l2 = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `num_loss_partitions` attribute.
    pub fn num_loss_partitions<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.num_loss_partitions = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `num_inner_iterations` attribute.
    pub fn num_inner_iterations<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.num_inner_iterations = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SdcaOptimizer` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
        O6: ::std::convert::Into<crate::Output>,
        O7: ::std::convert::Into<crate::Output>,
        O8: ::std::convert::Into<crate::Output>,
        O9: ::std::convert::Into<crate::Output>,
    >(
        &self,
        sparse_example_indices: O0,
        sparse_feature_indices: O1,
        sparse_feature_values: O2,
        dense_features: O3,
        example_weights: O4,
        example_labels: O5,
        sparse_indices: O6,
        sparse_weights: O7,
        dense_weights: O8,
        example_state_data: O9,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            sparse_example_indices.into(),
            sparse_feature_indices.into(),
            sparse_feature_values.into(),
            dense_features.into(),
            example_weights.into(),
            example_labels.into(),
            sparse_indices.into(),
            sparse_weights.into(),
            dense_weights.into(),
            example_state_data.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        sparse_example_indices: crate::Output,
        sparse_feature_indices: crate::Output,
        sparse_feature_values: crate::Output,
        dense_features: crate::Output,
        example_weights: crate::Output,
        example_labels: crate::Output,
        sparse_indices: crate::Output,
        sparse_weights: crate::Output,
        dense_weights: crate::Output,
        example_state_data: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SdcaOptimizer", |nd| {
            nd.add_input(sparse_example_indices);
            nd.add_input(sparse_feature_indices);
            nd.add_input(sparse_feature_values);
            nd.add_input(dense_features);
            nd.add_input(example_weights);
            nd.add_input(example_labels);
            nd.add_input(sparse_indices);
            nd.add_input(sparse_weights);
            nd.add_input(dense_weights);
            nd.add_input(example_state_data);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.loss_type {
                nd.set_attr_string("loss_type", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.adaptative {
                nd.set_attr_bool("adaptative", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_sparse_features {
                nd.set_attr_int("num_sparse_features", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_sparse_features_with_values {
                nd.set_attr_int("num_sparse_features_with_values", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_dense_features {
                nd.set_attr_int("num_dense_features", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.l1 {
                nd.set_attr_float("l1", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.l2 {
                nd.set_attr_float("l2", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_loss_partitions {
                nd.set_attr_int("num_loss_partitions", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_inner_iterations {
                nd.set_attr_int("num_inner_iterations", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SdcaOptimizer' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        sparse_example_indices: Vec<crate::Output>,
        sparse_feature_indices: Vec<crate::Output>,
        sparse_feature_values: Vec<crate::Output>,
        dense_features: Vec<crate::Output>,
        example_weights: crate::Output,
        example_labels: crate::Output,
        sparse_indices: Vec<crate::Output>,
        sparse_weights: Vec<crate::Output>,
        dense_weights: Vec<crate::Output>,
        example_state_data: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SdcaOptimizerInst> {
        let op = scope.new_operation("SdcaOptimizer", |builder| {
            builder.add_input_list(&sparse_example_indices);
            builder.add_input_list(&sparse_feature_indices);
            builder.add_input_list(&sparse_feature_values);
            builder.add_input_list(&dense_features);
            builder.add_input(example_weights);
            builder.add_input(example_labels);
            builder.add_input_list(&sparse_indices);
            builder.add_input_list(&sparse_weights);
            builder.add_input_list(&dense_weights);
            builder.add_input(example_state_data);
            if let ::std::option::Option::Some(value) = &self.loss_type {
                builder.set_attr_string("loss_type", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.adaptative {
                builder.set_attr_bool("adaptative", *value)?;
            }
            builder.set_attr_int(
                "num_sparse_features",
                sparse_example_indices.clone().len() as i64,
            )?;
            builder.set_attr_int(
                "num_sparse_features_with_values",
                sparse_feature_values.clone().len() as i64,
            )?;
            builder.set_attr_int("num_dense_features", dense_features.clone().len() as i64)?;
            if let ::std::option::Option::Some(value) = &self.l1 {
                builder.set_attr_float("l1", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.l2 {
                builder.set_attr_float("l2", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_loss_partitions {
                builder.set_attr_int("num_loss_partitions", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_inner_iterations {
                builder.set_attr_int("num_inner_iterations", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SdcaOptimizerInst { op })
    }
}
impl SdcaOptimizerInst {
    /// Returns the 'out_example_state_data' Output of this 'SdcaOptimizer' operation.
    pub fn out_example_state_data(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns a Vector of out_delta_sparse_weights for 'out_delta_sparse_weights' Output of this SdcaOptimizer operation.
    pub fn out_delta_sparse_weights(&self) -> crate::Result<Vec<crate::Output>> {
        let mut Outputs = vec![];
        for i in 1..self.op.get_attr_int("num_sparse_features")? as i32 {
            Outputs.push(crate::Output {
                operation: self.op.clone(),
                index: i,
            });
        }
        Ok(Outputs)
    }
    /// Returns a Vector of out_delta_dense_weights for 'out_delta_dense_weights' Output of this SdcaOptimizer operation.
    pub fn out_delta_dense_weights(&self) -> crate::Result<Vec<crate::Output>> {
        let dynamic_offset = (self.op.get_attr_int("num_sparse_features")? + 2) as i32;
        let mut Outputs = vec![];
        for i in dynamic_offset..dynamic_offset + self.op.get_attr_int("num_dense_features")? as i32
        {
            Outputs.push(crate::Output {
                operation: self.op.clone(),
                index: i,
            });
        }
        Ok(Outputs)
    }
    /// Returns a Vector of sparse_example_indices for 'sparse_example_indices' Input of this SdcaOptimizer operation.
    pub fn sparse_example_indices(&self) -> crate::Result<Vec<crate::Input>> {
        let mut Inputs = vec![];
        for i in 0..self.op.get_attr_int("num_sparse_features")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
    /// Returns a Vector of sparse_feature_indices for 'sparse_feature_indices' Input of this SdcaOptimizer operation.
    pub fn sparse_feature_indices(&self) -> crate::Result<Vec<crate::Input>> {
        let dynamic_offset = (self.op.get_attr_int("num_sparse_features")? + 1) as i32;
        let mut Inputs = vec![];
        for i in
            dynamic_offset..dynamic_offset + self.op.get_attr_int("num_sparse_features")? as i32
        {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
    /// Returns a Vector of sparse_feature_values for 'sparse_feature_values' Input of this SdcaOptimizer operation.
    pub fn sparse_feature_values(&self) -> crate::Result<Vec<crate::Input>> {
        let dynamic_offset = (2 * self.op.get_attr_int("num_sparse_features")? + 2) as i32;
        let mut Inputs = vec![];
        for i in dynamic_offset
            ..dynamic_offset + self.op.get_attr_int("num_sparse_features_with_values")? as i32
        {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
    /// Returns a Vector of dense_features for 'dense_features' Input of this SdcaOptimizer operation.
    pub fn dense_features(&self) -> crate::Result<Vec<crate::Input>> {
        let dynamic_offset = (self.op.get_attr_int("num_sparse_features_with_values")?
            + 2 * self.op.get_attr_int("num_sparse_features")?
            + 3) as i32;
        let mut Inputs = vec![];
        for i in dynamic_offset..dynamic_offset + self.op.get_attr_int("num_dense_features")? as i32
        {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
    /// Returns the 'example_weights' Input of this 'SdcaOptimizer' operation.
    pub fn example_weights(&self) -> crate::Result<crate::Input> {
        let dynamic_offset = (2 * self.op.get_attr_int("num_sparse_features")?
            + self.op.get_attr_int("num_sparse_features_with_values")?
            + self.op.get_attr_int("num_dense_features")?
            + 4) as i32;
        Ok(crate::Input {
            operation: &self.op,
            index: dynamic_offset,
        })
    }
    /// Returns the 'example_labels' Input of this 'SdcaOptimizer' operation.
    pub fn example_labels(&self) -> crate::Result<crate::Input> {
        let dynamic_offset = (self.op.get_attr_int("num_sparse_features_with_values")?
            + self.op.get_attr_int("num_dense_features")?
            + 2 * self.op.get_attr_int("num_sparse_features")?
            + 5) as i32;
        Ok(crate::Input {
            operation: &self.op,
            index: dynamic_offset,
        })
    }
    /// Returns a Vector of sparse_indices for 'sparse_indices' Input of this SdcaOptimizer operation.
    pub fn sparse_indices(&self) -> crate::Result<Vec<crate::Input>> {
        let dynamic_offset = (self.op.get_attr_int("num_dense_features")?
            + 2 * self.op.get_attr_int("num_sparse_features")?
            + self.op.get_attr_int("num_sparse_features_with_values")?
            + 6) as i32;
        let mut Inputs = vec![];
        for i in
            dynamic_offset..dynamic_offset + self.op.get_attr_int("num_sparse_features")? as i32
        {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
    /// Returns a Vector of sparse_weights for 'sparse_weights' Input of this SdcaOptimizer operation.
    pub fn sparse_weights(&self) -> crate::Result<Vec<crate::Input>> {
        let dynamic_offset = (self.op.get_attr_int("num_sparse_features_with_values")?
            + self.op.get_attr_int("num_dense_features")?
            + 3 * self.op.get_attr_int("num_sparse_features")?
            + 7) as i32;
        let mut Inputs = vec![];
        for i in
            dynamic_offset..dynamic_offset + self.op.get_attr_int("num_sparse_features")? as i32
        {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
    /// Returns a Vector of dense_weights for 'dense_weights' Input of this SdcaOptimizer operation.
    pub fn dense_weights(&self) -> crate::Result<Vec<crate::Input>> {
        let dynamic_offset = (self.op.get_attr_int("num_sparse_features_with_values")?
            + 4 * self.op.get_attr_int("num_sparse_features")?
            + self.op.get_attr_int("num_dense_features")?
            + 8) as i32;
        let mut Inputs = vec![];
        for i in dynamic_offset..dynamic_offset + self.op.get_attr_int("num_dense_features")? as i32
        {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
    /// Returns the 'example_state_data' Input of this 'SdcaOptimizer' operation.
    pub fn example_state_data(&self) -> crate::Result<crate::Input> {
        let dynamic_offset = (self.op.get_attr_int("num_sparse_features_with_values")?
            + 2 * self.op.get_attr_int("num_dense_features")?
            + 4 * self.op.get_attr_int("num_sparse_features")?
            + 9) as i32;
        Ok(crate::Input {
            operation: &self.op,
            index: dynamic_offset,
        })
    }
}
impl From<SdcaOptimizerInst> for crate::Operation {
    fn from(inst: SdcaOptimizerInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SdcaOptimizer::new().build(sparse_example_indices, sparse_feature_indices, sparse_feature_values, dense_features, example_weights, example_labels, sparse_indices, sparse_weights, dense_weights, example_state_data, scope)`.
pub fn sdca_optimizer<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
    O6: ::std::convert::Into<crate::Output>,
    O7: ::std::convert::Into<crate::Output>,
    O8: ::std::convert::Into<crate::Output>,
    O9: ::std::convert::Into<crate::Output>,
>(
    sparse_example_indices: O0,
    sparse_feature_indices: O1,
    sparse_feature_values: O2,
    dense_features: O3,
    example_weights: O4,
    example_labels: O5,
    sparse_indices: O6,
    sparse_weights: O7,
    dense_weights: O8,
    example_state_data: O9,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SdcaOptimizer::new().build(
        sparse_example_indices,
        sparse_feature_indices,
        sparse_feature_values,
        dense_features,
        example_weights,
        example_labels,
        sparse_indices,
        sparse_weights,
        dense_weights,
        example_state_data,
        scope,
    )
}

/// Builder for the `SdcaOptimizerV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SdcaOptimizerV2 {
    loss_type: ::std::option::Option<::std::string::String>,
    adaptive: ::std::option::Option<bool>,
    num_sparse_features: ::std::option::Option<i64>,
    num_sparse_features_with_values: ::std::option::Option<i64>,
    num_dense_features: ::std::option::Option<i64>,
    l1: ::std::option::Option<f32>,
    l2: ::std::option::Option<f32>,
    num_loss_partitions: ::std::option::Option<i64>,
    num_inner_iterations: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SdcaOptimizerV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SdcaOptimizerV2Inst {
    /// An instance of a fully built SdcaOptimizerV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SdcaOptimizerV2 {
    /// Creates a new `SdcaOptimizerV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `loss_type` attribute.
    pub fn loss_type<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.loss_type = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `adaptive` attribute.
    pub fn adaptive<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.adaptive = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `num_sparse_features` attribute.
    pub fn num_sparse_features<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.num_sparse_features = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `num_sparse_features_with_values` attribute.
    pub fn num_sparse_features_with_values<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.num_sparse_features_with_values = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `num_dense_features` attribute.
    pub fn num_dense_features<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.num_dense_features = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `l1` attribute.
    pub fn l1<ArgType: ::std::convert::Into<f32>>(mut self, value: ArgType) -> Self {
        self.l1 = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `l2` attribute.
    pub fn l2<ArgType: ::std::convert::Into<f32>>(mut self, value: ArgType) -> Self {
        self.l2 = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `num_loss_partitions` attribute.
    pub fn num_loss_partitions<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.num_loss_partitions = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `num_inner_iterations` attribute.
    pub fn num_inner_iterations<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.num_inner_iterations = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SdcaOptimizerV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
        O6: ::std::convert::Into<crate::Output>,
        O7: ::std::convert::Into<crate::Output>,
        O8: ::std::convert::Into<crate::Output>,
        O9: ::std::convert::Into<crate::Output>,
    >(
        &self,
        sparse_example_indices: O0,
        sparse_feature_indices: O1,
        sparse_feature_values: O2,
        dense_features: O3,
        example_weights: O4,
        example_labels: O5,
        sparse_indices: O6,
        sparse_weights: O7,
        dense_weights: O8,
        example_state_data: O9,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            sparse_example_indices.into(),
            sparse_feature_indices.into(),
            sparse_feature_values.into(),
            dense_features.into(),
            example_weights.into(),
            example_labels.into(),
            sparse_indices.into(),
            sparse_weights.into(),
            dense_weights.into(),
            example_state_data.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        sparse_example_indices: crate::Output,
        sparse_feature_indices: crate::Output,
        sparse_feature_values: crate::Output,
        dense_features: crate::Output,
        example_weights: crate::Output,
        example_labels: crate::Output,
        sparse_indices: crate::Output,
        sparse_weights: crate::Output,
        dense_weights: crate::Output,
        example_state_data: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SdcaOptimizerV2", |nd| {
            nd.add_input(sparse_example_indices);
            nd.add_input(sparse_feature_indices);
            nd.add_input(sparse_feature_values);
            nd.add_input(dense_features);
            nd.add_input(example_weights);
            nd.add_input(example_labels);
            nd.add_input(sparse_indices);
            nd.add_input(sparse_weights);
            nd.add_input(dense_weights);
            nd.add_input(example_state_data);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.loss_type {
                nd.set_attr_string("loss_type", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.adaptive {
                nd.set_attr_bool("adaptive", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_sparse_features {
                nd.set_attr_int("num_sparse_features", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_sparse_features_with_values {
                nd.set_attr_int("num_sparse_features_with_values", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_dense_features {
                nd.set_attr_int("num_dense_features", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.l1 {
                nd.set_attr_float("l1", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.l2 {
                nd.set_attr_float("l2", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_loss_partitions {
                nd.set_attr_int("num_loss_partitions", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_inner_iterations {
                nd.set_attr_int("num_inner_iterations", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SdcaOptimizerV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        sparse_example_indices: Vec<crate::Output>,
        sparse_feature_indices: Vec<crate::Output>,
        sparse_feature_values: Vec<crate::Output>,
        dense_features: Vec<crate::Output>,
        example_weights: crate::Output,
        example_labels: crate::Output,
        sparse_indices: Vec<crate::Output>,
        sparse_weights: Vec<crate::Output>,
        dense_weights: Vec<crate::Output>,
        example_state_data: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SdcaOptimizerV2Inst> {
        let op = scope.new_operation("SdcaOptimizerV2", |builder| {
            builder.add_input_list(&sparse_example_indices);
            builder.add_input_list(&sparse_feature_indices);
            builder.add_input_list(&sparse_feature_values);
            builder.add_input_list(&dense_features);
            builder.add_input(example_weights);
            builder.add_input(example_labels);
            builder.add_input_list(&sparse_indices);
            builder.add_input_list(&sparse_weights);
            builder.add_input_list(&dense_weights);
            builder.add_input(example_state_data);
            if let ::std::option::Option::Some(value) = &self.loss_type {
                builder.set_attr_string("loss_type", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.adaptive {
                builder.set_attr_bool("adaptive", *value)?;
            }
            builder.set_attr_int(
                "num_sparse_features",
                sparse_example_indices.clone().len() as i64,
            )?;
            builder.set_attr_int(
                "num_sparse_features_with_values",
                sparse_feature_values.clone().len() as i64,
            )?;
            builder.set_attr_int("num_dense_features", dense_features.clone().len() as i64)?;
            if let ::std::option::Option::Some(value) = &self.l1 {
                builder.set_attr_float("l1", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.l2 {
                builder.set_attr_float("l2", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_loss_partitions {
                builder.set_attr_int("num_loss_partitions", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_inner_iterations {
                builder.set_attr_int("num_inner_iterations", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SdcaOptimizerV2Inst { op })
    }
}
impl SdcaOptimizerV2Inst {
    /// Returns the 'out_example_state_data' Output of this 'SdcaOptimizerV2' operation.
    pub fn out_example_state_data(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns a Vector of out_delta_sparse_weights for 'out_delta_sparse_weights' Output of this SdcaOptimizerV2 operation.
    pub fn out_delta_sparse_weights(&self) -> crate::Result<Vec<crate::Output>> {
        let mut Outputs = vec![];
        for i in 1..self.op.get_attr_int("num_sparse_features")? as i32 {
            Outputs.push(crate::Output {
                operation: self.op.clone(),
                index: i,
            });
        }
        Ok(Outputs)
    }
    /// Returns a Vector of out_delta_dense_weights for 'out_delta_dense_weights' Output of this SdcaOptimizerV2 operation.
    pub fn out_delta_dense_weights(&self) -> crate::Result<Vec<crate::Output>> {
        let dynamic_offset = (self.op.get_attr_int("num_sparse_features")? + 2) as i32;
        let mut Outputs = vec![];
        for i in dynamic_offset..dynamic_offset + self.op.get_attr_int("num_dense_features")? as i32
        {
            Outputs.push(crate::Output {
                operation: self.op.clone(),
                index: i,
            });
        }
        Ok(Outputs)
    }
    /// Returns a Vector of sparse_example_indices for 'sparse_example_indices' Input of this SdcaOptimizerV2 operation.
    pub fn sparse_example_indices(&self) -> crate::Result<Vec<crate::Input>> {
        let mut Inputs = vec![];
        for i in 0..self.op.get_attr_int("num_sparse_features")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
    /// Returns a Vector of sparse_feature_indices for 'sparse_feature_indices' Input of this SdcaOptimizerV2 operation.
    pub fn sparse_feature_indices(&self) -> crate::Result<Vec<crate::Input>> {
        let dynamic_offset = (self.op.get_attr_int("num_sparse_features")? + 1) as i32;
        let mut Inputs = vec![];
        for i in
            dynamic_offset..dynamic_offset + self.op.get_attr_int("num_sparse_features")? as i32
        {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
    /// Returns a Vector of sparse_feature_values for 'sparse_feature_values' Input of this SdcaOptimizerV2 operation.
    pub fn sparse_feature_values(&self) -> crate::Result<Vec<crate::Input>> {
        let dynamic_offset = (2 * self.op.get_attr_int("num_sparse_features")? + 2) as i32;
        let mut Inputs = vec![];
        for i in dynamic_offset
            ..dynamic_offset + self.op.get_attr_int("num_sparse_features_with_values")? as i32
        {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
    /// Returns a Vector of dense_features for 'dense_features' Input of this SdcaOptimizerV2 operation.
    pub fn dense_features(&self) -> crate::Result<Vec<crate::Input>> {
        let dynamic_offset = (self.op.get_attr_int("num_sparse_features_with_values")?
            + 2 * self.op.get_attr_int("num_sparse_features")?
            + 3) as i32;
        let mut Inputs = vec![];
        for i in dynamic_offset..dynamic_offset + self.op.get_attr_int("num_dense_features")? as i32
        {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
    /// Returns the 'example_weights' Input of this 'SdcaOptimizerV2' operation.
    pub fn example_weights(&self) -> crate::Result<crate::Input> {
        let dynamic_offset = (self.op.get_attr_int("num_sparse_features_with_values")?
            + self.op.get_attr_int("num_dense_features")?
            + 2 * self.op.get_attr_int("num_sparse_features")?
            + 4) as i32;
        Ok(crate::Input {
            operation: &self.op,
            index: dynamic_offset,
        })
    }
    /// Returns the 'example_labels' Input of this 'SdcaOptimizerV2' operation.
    pub fn example_labels(&self) -> crate::Result<crate::Input> {
        let dynamic_offset = (self.op.get_attr_int("num_dense_features")?
            + 2 * self.op.get_attr_int("num_sparse_features")?
            + self.op.get_attr_int("num_sparse_features_with_values")?
            + 5) as i32;
        Ok(crate::Input {
            operation: &self.op,
            index: dynamic_offset,
        })
    }
    /// Returns a Vector of sparse_indices for 'sparse_indices' Input of this SdcaOptimizerV2 operation.
    pub fn sparse_indices(&self) -> crate::Result<Vec<crate::Input>> {
        let dynamic_offset = (self.op.get_attr_int("num_sparse_features_with_values")?
            + self.op.get_attr_int("num_dense_features")?
            + 2 * self.op.get_attr_int("num_sparse_features")?
            + 6) as i32;
        let mut Inputs = vec![];
        for i in
            dynamic_offset..dynamic_offset + self.op.get_attr_int("num_sparse_features")? as i32
        {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
    /// Returns a Vector of sparse_weights for 'sparse_weights' Input of this SdcaOptimizerV2 operation.
    pub fn sparse_weights(&self) -> crate::Result<Vec<crate::Input>> {
        let dynamic_offset = (self.op.get_attr_int("num_dense_features")?
            + 3 * self.op.get_attr_int("num_sparse_features")?
            + self.op.get_attr_int("num_sparse_features_with_values")?
            + 7) as i32;
        let mut Inputs = vec![];
        for i in
            dynamic_offset..dynamic_offset + self.op.get_attr_int("num_sparse_features")? as i32
        {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
    /// Returns a Vector of dense_weights for 'dense_weights' Input of this SdcaOptimizerV2 operation.
    pub fn dense_weights(&self) -> crate::Result<Vec<crate::Input>> {
        let dynamic_offset = (4 * self.op.get_attr_int("num_sparse_features")?
            + self.op.get_attr_int("num_dense_features")?
            + self.op.get_attr_int("num_sparse_features_with_values")?
            + 8) as i32;
        let mut Inputs = vec![];
        for i in dynamic_offset..dynamic_offset + self.op.get_attr_int("num_dense_features")? as i32
        {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
    /// Returns the 'example_state_data' Input of this 'SdcaOptimizerV2' operation.
    pub fn example_state_data(&self) -> crate::Result<crate::Input> {
        let dynamic_offset = (4 * self.op.get_attr_int("num_sparse_features")?
            + self.op.get_attr_int("num_sparse_features_with_values")?
            + 2 * self.op.get_attr_int("num_dense_features")?
            + 9) as i32;
        Ok(crate::Input {
            operation: &self.op,
            index: dynamic_offset,
        })
    }
}
impl From<SdcaOptimizerV2Inst> for crate::Operation {
    fn from(inst: SdcaOptimizerV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SdcaOptimizerV2::new().build(sparse_example_indices, sparse_feature_indices, sparse_feature_values, dense_features, example_weights, example_labels, sparse_indices, sparse_weights, dense_weights, example_state_data, scope)`.
pub fn sdca_optimizer_v2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
    O6: ::std::convert::Into<crate::Output>,
    O7: ::std::convert::Into<crate::Output>,
    O8: ::std::convert::Into<crate::Output>,
    O9: ::std::convert::Into<crate::Output>,
>(
    sparse_example_indices: O0,
    sparse_feature_indices: O1,
    sparse_feature_values: O2,
    dense_features: O3,
    example_weights: O4,
    example_labels: O5,
    sparse_indices: O6,
    sparse_weights: O7,
    dense_weights: O8,
    example_state_data: O9,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SdcaOptimizerV2::new().build(
        sparse_example_indices,
        sparse_feature_indices,
        sparse_feature_values,
        dense_features,
        example_weights,
        example_labels,
        sparse_indices,
        sparse_weights,
        dense_weights,
        example_state_data,
        scope,
    )
}

/// Builder for the `SdcaShrinkL1` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SdcaShrinkL1 {
    num_features: ::std::option::Option<i64>,
    l1: ::std::option::Option<f32>,
    l2: ::std::option::Option<f32>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SdcaShrinkL1' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SdcaShrinkL1Inst {
    /// An instance of a fully built SdcaShrinkL1 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SdcaShrinkL1 {
    /// Creates a new `SdcaShrinkL1`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `num_features` attribute.
    pub fn num_features<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.num_features = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `l1` attribute.
    pub fn l1<ArgType: ::std::convert::Into<f32>>(mut self, value: ArgType) -> Self {
        self.l1 = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `l2` attribute.
    pub fn l2<ArgType: ::std::convert::Into<f32>>(mut self, value: ArgType) -> Self {
        self.l2 = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SdcaShrinkL1` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        weights: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(weights.into(), scope)
    }
    fn build_impl(
        &self,
        weights: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SdcaShrinkL1", |nd| {
            nd.add_input(weights);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.num_features {
                nd.set_attr_int("num_features", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.l1 {
                nd.set_attr_float("l1", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.l2 {
                nd.set_attr_float("l2", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SdcaShrinkL1' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        weights: Vec<crate::Output>,
        scope: &mut crate::Scope,
    ) -> crate::Result<SdcaShrinkL1Inst> {
        let op = scope.new_operation("SdcaShrinkL1", |builder| {
            builder.add_input_list(&weights);
            builder.set_attr_int("num_features", weights.clone().len() as i64)?;
            if let ::std::option::Option::Some(value) = &self.l1 {
                builder.set_attr_float("l1", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.l2 {
                builder.set_attr_float("l2", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SdcaShrinkL1Inst { op })
    }
}
impl SdcaShrinkL1Inst {
    /// Returns a Vector of weights for 'weights' Input of this SdcaShrinkL1 operation.
    pub fn weights(&self) -> crate::Result<Vec<crate::Input>> {
        let mut Inputs = vec![];
        for i in 0..self.op.get_attr_int("num_features")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
}
impl From<SdcaShrinkL1Inst> for crate::Operation {
    fn from(inst: SdcaShrinkL1Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SdcaShrinkL1::new().build(weights, scope)`.
pub fn sdca_shrink_l1<O0: ::std::convert::Into<crate::Output>>(
    weights: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SdcaShrinkL1::new().build(weights, scope)
}

/// Builder for the `SegmentMax` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SegmentMax {
    T: ::std::option::Option<crate::DataType>,
    Tindices: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SegmentMax' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SegmentMaxInst {
    /// An instance of a fully built SegmentMax Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SegmentMax {
    /// Creates a new `SegmentMax`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tindices` attribute.
    pub fn Tindices<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tindices = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SegmentMax` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        data: O0,
        segment_ids: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(data.into(), segment_ids.into(), scope)
    }
    fn build_impl(
        &self,
        data: crate::Output,
        segment_ids: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SegmentMax", |nd| {
            nd.add_input(data);
            nd.add_input(segment_ids);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                nd.set_attr_type("Tindices", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SegmentMax' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        data: crate::Output,
        segment_ids: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SegmentMaxInst> {
        let op = scope.new_operation("SegmentMax", |builder| {
            builder.add_input(data);
            builder.add_input(segment_ids);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                builder.set_attr_type("Tindices", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SegmentMaxInst { op })
    }
}
impl SegmentMaxInst {
    /// Returns the 'output' Output of this 'SegmentMax' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'data' Input of this 'SegmentMax' operation.
    pub fn data(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'segment_ids' Input of this 'SegmentMax' operation.
    pub fn segment_ids(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<SegmentMaxInst> for crate::Operation {
    fn from(inst: SegmentMaxInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SegmentMax::new().build(data, segment_ids, scope)`.
pub fn segment_max<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    data: O0,
    segment_ids: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SegmentMax::new().build(data, segment_ids, scope)
}

/// Builder for the `SegmentMaxV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SegmentMaxV2 {
    T: ::std::option::Option<crate::DataType>,
    Tindices: ::std::option::Option<crate::DataType>,
    Tnumsegments: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SegmentMaxV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SegmentMaxV2Inst {
    /// An instance of a fully built SegmentMaxV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SegmentMaxV2 {
    /// Creates a new `SegmentMaxV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tindices` attribute.
    pub fn Tindices<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tindices = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tnumsegments` attribute.
    pub fn Tnumsegments<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tnumsegments = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SegmentMaxV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        data: O0,
        segment_ids: O1,
        num_segments: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(data.into(), segment_ids.into(), num_segments.into(), scope)
    }
    fn build_impl(
        &self,
        data: crate::Output,
        segment_ids: crate::Output,
        num_segments: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SegmentMaxV2", |nd| {
            nd.add_input(data);
            nd.add_input(segment_ids);
            nd.add_input(num_segments);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                nd.set_attr_type("Tindices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tnumsegments {
                nd.set_attr_type("Tnumsegments", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SegmentMaxV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        data: crate::Output,
        segment_ids: crate::Output,
        num_segments: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SegmentMaxV2Inst> {
        let op = scope.new_operation("SegmentMaxV2", |builder| {
            builder.add_input(data);
            builder.add_input(segment_ids);
            builder.add_input(num_segments);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                builder.set_attr_type("Tindices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tnumsegments {
                builder.set_attr_type("Tnumsegments", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SegmentMaxV2Inst { op })
    }
}
impl SegmentMaxV2Inst {
    /// Returns the 'output' Output of this 'SegmentMaxV2' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'data' Input of this 'SegmentMaxV2' operation.
    pub fn data(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'segment_ids' Input of this 'SegmentMaxV2' operation.
    pub fn segment_ids(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'num_segments' Input of this 'SegmentMaxV2' operation.
    pub fn num_segments(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<SegmentMaxV2Inst> for crate::Operation {
    fn from(inst: SegmentMaxV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SegmentMaxV2::new().build(data, segment_ids, num_segments, scope)`.
pub fn segment_max_v2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    data: O0,
    segment_ids: O1,
    num_segments: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SegmentMaxV2::new().build(data, segment_ids, num_segments, scope)
}

/// Builder for the `SegmentMean` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SegmentMean {
    T: ::std::option::Option<crate::DataType>,
    Tindices: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SegmentMean' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SegmentMeanInst {
    /// An instance of a fully built SegmentMean Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SegmentMean {
    /// Creates a new `SegmentMean`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tindices` attribute.
    pub fn Tindices<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tindices = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SegmentMean` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        data: O0,
        segment_ids: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(data.into(), segment_ids.into(), scope)
    }
    fn build_impl(
        &self,
        data: crate::Output,
        segment_ids: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SegmentMean", |nd| {
            nd.add_input(data);
            nd.add_input(segment_ids);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                nd.set_attr_type("Tindices", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SegmentMean' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        data: crate::Output,
        segment_ids: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SegmentMeanInst> {
        let op = scope.new_operation("SegmentMean", |builder| {
            builder.add_input(data);
            builder.add_input(segment_ids);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                builder.set_attr_type("Tindices", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SegmentMeanInst { op })
    }
}
impl SegmentMeanInst {
    /// Returns the 'output' Output of this 'SegmentMean' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'data' Input of this 'SegmentMean' operation.
    pub fn data(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'segment_ids' Input of this 'SegmentMean' operation.
    pub fn segment_ids(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<SegmentMeanInst> for crate::Operation {
    fn from(inst: SegmentMeanInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SegmentMean::new().build(data, segment_ids, scope)`.
pub fn segment_mean<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    data: O0,
    segment_ids: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SegmentMean::new().build(data, segment_ids, scope)
}

/// Builder for the `SegmentMin` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SegmentMin {
    T: ::std::option::Option<crate::DataType>,
    Tindices: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SegmentMin' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SegmentMinInst {
    /// An instance of a fully built SegmentMin Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SegmentMin {
    /// Creates a new `SegmentMin`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tindices` attribute.
    pub fn Tindices<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tindices = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SegmentMin` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        data: O0,
        segment_ids: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(data.into(), segment_ids.into(), scope)
    }
    fn build_impl(
        &self,
        data: crate::Output,
        segment_ids: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SegmentMin", |nd| {
            nd.add_input(data);
            nd.add_input(segment_ids);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                nd.set_attr_type("Tindices", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SegmentMin' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        data: crate::Output,
        segment_ids: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SegmentMinInst> {
        let op = scope.new_operation("SegmentMin", |builder| {
            builder.add_input(data);
            builder.add_input(segment_ids);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                builder.set_attr_type("Tindices", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SegmentMinInst { op })
    }
}
impl SegmentMinInst {
    /// Returns the 'output' Output of this 'SegmentMin' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'data' Input of this 'SegmentMin' operation.
    pub fn data(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'segment_ids' Input of this 'SegmentMin' operation.
    pub fn segment_ids(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<SegmentMinInst> for crate::Operation {
    fn from(inst: SegmentMinInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SegmentMin::new().build(data, segment_ids, scope)`.
pub fn segment_min<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    data: O0,
    segment_ids: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SegmentMin::new().build(data, segment_ids, scope)
}

/// Builder for the `SegmentMinV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SegmentMinV2 {
    T: ::std::option::Option<crate::DataType>,
    Tindices: ::std::option::Option<crate::DataType>,
    Tnumsegments: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SegmentMinV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SegmentMinV2Inst {
    /// An instance of a fully built SegmentMinV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SegmentMinV2 {
    /// Creates a new `SegmentMinV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tindices` attribute.
    pub fn Tindices<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tindices = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tnumsegments` attribute.
    pub fn Tnumsegments<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tnumsegments = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SegmentMinV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        data: O0,
        segment_ids: O1,
        num_segments: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(data.into(), segment_ids.into(), num_segments.into(), scope)
    }
    fn build_impl(
        &self,
        data: crate::Output,
        segment_ids: crate::Output,
        num_segments: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SegmentMinV2", |nd| {
            nd.add_input(data);
            nd.add_input(segment_ids);
            nd.add_input(num_segments);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                nd.set_attr_type("Tindices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tnumsegments {
                nd.set_attr_type("Tnumsegments", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SegmentMinV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        data: crate::Output,
        segment_ids: crate::Output,
        num_segments: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SegmentMinV2Inst> {
        let op = scope.new_operation("SegmentMinV2", |builder| {
            builder.add_input(data);
            builder.add_input(segment_ids);
            builder.add_input(num_segments);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                builder.set_attr_type("Tindices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tnumsegments {
                builder.set_attr_type("Tnumsegments", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SegmentMinV2Inst { op })
    }
}
impl SegmentMinV2Inst {
    /// Returns the 'output' Output of this 'SegmentMinV2' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'data' Input of this 'SegmentMinV2' operation.
    pub fn data(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'segment_ids' Input of this 'SegmentMinV2' operation.
    pub fn segment_ids(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'num_segments' Input of this 'SegmentMinV2' operation.
    pub fn num_segments(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<SegmentMinV2Inst> for crate::Operation {
    fn from(inst: SegmentMinV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SegmentMinV2::new().build(data, segment_ids, num_segments, scope)`.
pub fn segment_min_v2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    data: O0,
    segment_ids: O1,
    num_segments: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SegmentMinV2::new().build(data, segment_ids, num_segments, scope)
}

/// Builder for the `SegmentProd` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SegmentProd {
    T: ::std::option::Option<crate::DataType>,
    Tindices: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SegmentProd' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SegmentProdInst {
    /// An instance of a fully built SegmentProd Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SegmentProd {
    /// Creates a new `SegmentProd`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tindices` attribute.
    pub fn Tindices<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tindices = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SegmentProd` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        data: O0,
        segment_ids: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(data.into(), segment_ids.into(), scope)
    }
    fn build_impl(
        &self,
        data: crate::Output,
        segment_ids: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SegmentProd", |nd| {
            nd.add_input(data);
            nd.add_input(segment_ids);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                nd.set_attr_type("Tindices", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SegmentProd' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        data: crate::Output,
        segment_ids: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SegmentProdInst> {
        let op = scope.new_operation("SegmentProd", |builder| {
            builder.add_input(data);
            builder.add_input(segment_ids);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                builder.set_attr_type("Tindices", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SegmentProdInst { op })
    }
}
impl SegmentProdInst {
    /// Returns the 'output' Output of this 'SegmentProd' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'data' Input of this 'SegmentProd' operation.
    pub fn data(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'segment_ids' Input of this 'SegmentProd' operation.
    pub fn segment_ids(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<SegmentProdInst> for crate::Operation {
    fn from(inst: SegmentProdInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SegmentProd::new().build(data, segment_ids, scope)`.
pub fn segment_prod<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    data: O0,
    segment_ids: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SegmentProd::new().build(data, segment_ids, scope)
}

/// Builder for the `SegmentProdV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SegmentProdV2 {
    T: ::std::option::Option<crate::DataType>,
    Tindices: ::std::option::Option<crate::DataType>,
    Tnumsegments: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SegmentProdV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SegmentProdV2Inst {
    /// An instance of a fully built SegmentProdV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SegmentProdV2 {
    /// Creates a new `SegmentProdV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tindices` attribute.
    pub fn Tindices<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tindices = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tnumsegments` attribute.
    pub fn Tnumsegments<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tnumsegments = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SegmentProdV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        data: O0,
        segment_ids: O1,
        num_segments: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(data.into(), segment_ids.into(), num_segments.into(), scope)
    }
    fn build_impl(
        &self,
        data: crate::Output,
        segment_ids: crate::Output,
        num_segments: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SegmentProdV2", |nd| {
            nd.add_input(data);
            nd.add_input(segment_ids);
            nd.add_input(num_segments);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                nd.set_attr_type("Tindices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tnumsegments {
                nd.set_attr_type("Tnumsegments", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SegmentProdV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        data: crate::Output,
        segment_ids: crate::Output,
        num_segments: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SegmentProdV2Inst> {
        let op = scope.new_operation("SegmentProdV2", |builder| {
            builder.add_input(data);
            builder.add_input(segment_ids);
            builder.add_input(num_segments);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                builder.set_attr_type("Tindices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tnumsegments {
                builder.set_attr_type("Tnumsegments", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SegmentProdV2Inst { op })
    }
}
impl SegmentProdV2Inst {
    /// Returns the 'output' Output of this 'SegmentProdV2' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'data' Input of this 'SegmentProdV2' operation.
    pub fn data(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'segment_ids' Input of this 'SegmentProdV2' operation.
    pub fn segment_ids(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'num_segments' Input of this 'SegmentProdV2' operation.
    pub fn num_segments(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<SegmentProdV2Inst> for crate::Operation {
    fn from(inst: SegmentProdV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SegmentProdV2::new().build(data, segment_ids, num_segments, scope)`.
pub fn segment_prod_v2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    data: O0,
    segment_ids: O1,
    num_segments: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SegmentProdV2::new().build(data, segment_ids, num_segments, scope)
}

/// Builder for the `SegmentSum` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SegmentSum {
    T: ::std::option::Option<crate::DataType>,
    Tindices: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SegmentSum' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SegmentSumInst {
    /// An instance of a fully built SegmentSum Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SegmentSum {
    /// Creates a new `SegmentSum`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tindices` attribute.
    pub fn Tindices<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tindices = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SegmentSum` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        data: O0,
        segment_ids: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(data.into(), segment_ids.into(), scope)
    }
    fn build_impl(
        &self,
        data: crate::Output,
        segment_ids: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SegmentSum", |nd| {
            nd.add_input(data);
            nd.add_input(segment_ids);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                nd.set_attr_type("Tindices", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SegmentSum' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        data: crate::Output,
        segment_ids: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SegmentSumInst> {
        let op = scope.new_operation("SegmentSum", |builder| {
            builder.add_input(data);
            builder.add_input(segment_ids);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                builder.set_attr_type("Tindices", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SegmentSumInst { op })
    }
}
impl SegmentSumInst {
    /// Returns the 'output' Output of this 'SegmentSum' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'data' Input of this 'SegmentSum' operation.
    pub fn data(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'segment_ids' Input of this 'SegmentSum' operation.
    pub fn segment_ids(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<SegmentSumInst> for crate::Operation {
    fn from(inst: SegmentSumInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SegmentSum::new().build(data, segment_ids, scope)`.
pub fn segment_sum<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    data: O0,
    segment_ids: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SegmentSum::new().build(data, segment_ids, scope)
}

/// Builder for the `SegmentSumV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SegmentSumV2 {
    T: ::std::option::Option<crate::DataType>,
    Tindices: ::std::option::Option<crate::DataType>,
    Tnumsegments: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SegmentSumV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SegmentSumV2Inst {
    /// An instance of a fully built SegmentSumV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SegmentSumV2 {
    /// Creates a new `SegmentSumV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tindices` attribute.
    pub fn Tindices<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tindices = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tnumsegments` attribute.
    pub fn Tnumsegments<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tnumsegments = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SegmentSumV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        data: O0,
        segment_ids: O1,
        num_segments: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(data.into(), segment_ids.into(), num_segments.into(), scope)
    }
    fn build_impl(
        &self,
        data: crate::Output,
        segment_ids: crate::Output,
        num_segments: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SegmentSumV2", |nd| {
            nd.add_input(data);
            nd.add_input(segment_ids);
            nd.add_input(num_segments);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                nd.set_attr_type("Tindices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tnumsegments {
                nd.set_attr_type("Tnumsegments", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SegmentSumV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        data: crate::Output,
        segment_ids: crate::Output,
        num_segments: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SegmentSumV2Inst> {
        let op = scope.new_operation("SegmentSumV2", |builder| {
            builder.add_input(data);
            builder.add_input(segment_ids);
            builder.add_input(num_segments);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                builder.set_attr_type("Tindices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tnumsegments {
                builder.set_attr_type("Tnumsegments", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SegmentSumV2Inst { op })
    }
}
impl SegmentSumV2Inst {
    /// Returns the 'output' Output of this 'SegmentSumV2' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'data' Input of this 'SegmentSumV2' operation.
    pub fn data(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'segment_ids' Input of this 'SegmentSumV2' operation.
    pub fn segment_ids(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'num_segments' Input of this 'SegmentSumV2' operation.
    pub fn num_segments(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<SegmentSumV2Inst> for crate::Operation {
    fn from(inst: SegmentSumV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SegmentSumV2::new().build(data, segment_ids, num_segments, scope)`.
pub fn segment_sum_v2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    data: O0,
    segment_ids: O1,
    num_segments: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SegmentSumV2::new().build(data, segment_ids, num_segments, scope)
}

/// Builder for the `Select` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Select {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Select' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SelectInst {
    /// An instance of a fully built Select Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Select {
    /// Creates a new `Select`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Select` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        condition: O0,
        t: O1,
        e: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(condition.into(), t.into(), e.into(), scope)
    }
    fn build_impl(
        &self,
        condition: crate::Output,
        t: crate::Output,
        e: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Select", |nd| {
            nd.add_input(condition);
            nd.add_input(t);
            nd.add_input(e);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Select' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        condition: crate::Output,
        t: crate::Output,
        e: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SelectInst> {
        let op = scope.new_operation("Select", |builder| {
            builder.add_input(condition);
            builder.add_input(t);
            builder.add_input(e);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SelectInst { op })
    }
}
impl SelectInst {
    /// Returns the 'output' Output of this 'Select' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'condition' Input of this 'Select' operation.
    pub fn condition(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 't' Input of this 'Select' operation.
    pub fn t(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'e' Input of this 'Select' operation.
    pub fn e(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<SelectInst> for crate::Operation {
    fn from(inst: SelectInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Select::new().build(condition, t, e, scope)`.
pub fn select<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    condition: O0,
    t: O1,
    e: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Select::new().build(condition, t, e, scope)
}

/// Builder for the `SelectV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SelectV2 {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SelectV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SelectV2Inst {
    /// An instance of a fully built SelectV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SelectV2 {
    /// Creates a new `SelectV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SelectV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        condition: O0,
        t: O1,
        e: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(condition.into(), t.into(), e.into(), scope)
    }
    fn build_impl(
        &self,
        condition: crate::Output,
        t: crate::Output,
        e: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SelectV2", |nd| {
            nd.add_input(condition);
            nd.add_input(t);
            nd.add_input(e);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SelectV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        condition: crate::Output,
        t: crate::Output,
        e: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SelectV2Inst> {
        let op = scope.new_operation("SelectV2", |builder| {
            builder.add_input(condition);
            builder.add_input(t);
            builder.add_input(e);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SelectV2Inst { op })
    }
}
impl SelectV2Inst {
    /// Returns the 'output' Output of this 'SelectV2' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'condition' Input of this 'SelectV2' operation.
    pub fn condition(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 't' Input of this 'SelectV2' operation.
    pub fn t(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'e' Input of this 'SelectV2' operation.
    pub fn e(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<SelectV2Inst> for crate::Operation {
    fn from(inst: SelectV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SelectV2::new().build(condition, t, e, scope)`.
pub fn select_v2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    condition: O0,
    t: O1,
    e: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SelectV2::new().build(condition, t, e, scope)
}

/// Builder for the `SelfAdjointEig` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SelfAdjointEig {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SelfAdjointEig' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SelfAdjointEigInst {
    /// An instance of a fully built SelfAdjointEig Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SelfAdjointEig {
    /// Creates a new `SelfAdjointEig`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SelfAdjointEig` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SelfAdjointEig", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SelfAdjointEig' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SelfAdjointEigInst> {
        let op = scope.new_operation("SelfAdjointEig", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SelfAdjointEigInst { op })
    }
}
impl SelfAdjointEigInst {
    /// Returns the 'output' Output of this 'SelfAdjointEig' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'SelfAdjointEig' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<SelfAdjointEigInst> for crate::Operation {
    fn from(inst: SelfAdjointEigInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SelfAdjointEig::new().build(input, scope)`.
pub fn self_adjoint_eig<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SelfAdjointEig::new().build(input, scope)
}

/// Builder for the `SelfAdjointEigV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SelfAdjointEigV2 {
    compute_v: ::std::option::Option<bool>,
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SelfAdjointEigV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SelfAdjointEigV2Inst {
    /// An instance of a fully built SelfAdjointEigV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SelfAdjointEigV2 {
    /// Creates a new `SelfAdjointEigV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `compute_v` attribute.
    pub fn compute_v<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.compute_v = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SelfAdjointEigV2` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SelfAdjointEigV2", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.compute_v {
                nd.set_attr_bool("compute_v", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SelfAdjointEigV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SelfAdjointEigV2Inst> {
        let op = scope.new_operation("SelfAdjointEigV2", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.compute_v {
                builder.set_attr_bool("compute_v", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SelfAdjointEigV2Inst { op })
    }
}
impl SelfAdjointEigV2Inst {
    /// Returns the 'e' Output of this 'SelfAdjointEigV2' operation.
    pub fn e(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'v' Output of this 'SelfAdjointEigV2' operation.
    pub fn v(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'input' Input of this 'SelfAdjointEigV2' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<SelfAdjointEigV2Inst> for crate::Operation {
    fn from(inst: SelfAdjointEigV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SelfAdjointEigV2::new().build(input, scope)`.
pub fn self_adjoint_eig_v2<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SelfAdjointEigV2::new().build(input, scope)
}

/// Builder for the `Selu` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Selu {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Selu' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SeluInst {
    /// An instance of a fully built Selu Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Selu {
    /// Creates a new `Selu`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Selu` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        features: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(features.into(), scope)
    }
    fn build_impl(
        &self,
        features: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Selu", |nd| {
            nd.add_input(features);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Selu' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        features: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SeluInst> {
        let op = scope.new_operation("Selu", |builder| {
            builder.add_input(features);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SeluInst { op })
    }
}
impl SeluInst {
    /// Returns the 'activations' Output of this 'Selu' operation.
    pub fn activations(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'features' Input of this 'Selu' operation.
    pub fn features(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<SeluInst> for crate::Operation {
    fn from(inst: SeluInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Selu::new().build(features, scope)`.
pub fn selu<O0: ::std::convert::Into<crate::Output>>(
    features: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Selu::new().build(features, scope)
}

/// Builder for the `SeluGrad` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SeluGrad {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SeluGrad' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SeluGradInst {
    /// An instance of a fully built SeluGrad Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SeluGrad {
    /// Creates a new `SeluGrad`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SeluGrad` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        gradients: O0,
        outputs: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(gradients.into(), outputs.into(), scope)
    }
    fn build_impl(
        &self,
        gradients: crate::Output,
        outputs: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SeluGrad", |nd| {
            nd.add_input(gradients);
            nd.add_input(outputs);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SeluGrad' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        gradients: crate::Output,
        outputs: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SeluGradInst> {
        let op = scope.new_operation("SeluGrad", |builder| {
            builder.add_input(gradients);
            builder.add_input(outputs);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SeluGradInst { op })
    }
}
impl SeluGradInst {
    /// Returns the 'backprops' Output of this 'SeluGrad' operation.
    pub fn backprops(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'gradients' Input of this 'SeluGrad' operation.
    pub fn gradients(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'outputs' Input of this 'SeluGrad' operation.
    pub fn outputs(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<SeluGradInst> for crate::Operation {
    fn from(inst: SeluGradInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SeluGrad::new().build(gradients, outputs, scope)`.
pub fn selu_grad<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    gradients: O0,
    outputs: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SeluGrad::new().build(gradients, outputs, scope)
}

/// Builder for the `Send` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Send {
    T: ::std::option::Option<crate::DataType>,
    tensor_name: ::std::option::Option<::std::string::String>,
    send_device: ::std::option::Option<::std::string::String>,
    send_device_incarnation: ::std::option::Option<i64>,
    recv_device: ::std::option::Option<::std::string::String>,
    client_terminated: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Send' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SendInst {
    /// An instance of a fully built Send Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Send {
    /// Creates a new `Send`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `tensor_name` attribute.
    pub fn tensor_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.tensor_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `send_device` attribute.
    pub fn send_device<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.send_device = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `send_device_incarnation` attribute.
    pub fn send_device_incarnation<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.send_device_incarnation = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `recv_device` attribute.
    pub fn recv_device<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.recv_device = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `client_terminated` attribute.
    pub fn client_terminated<ArgType: ::std::convert::Into<bool>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.client_terminated = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Send` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        tensor: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(tensor.into(), scope)
    }
    fn build_impl(
        &self,
        tensor: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Send", |nd| {
            nd.add_input(tensor);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.tensor_name {
                nd.set_attr_string("tensor_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.send_device {
                nd.set_attr_string("send_device", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.send_device_incarnation {
                nd.set_attr_int("send_device_incarnation", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.recv_device {
                nd.set_attr_string("recv_device", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.client_terminated {
                nd.set_attr_bool("client_terminated", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Send' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        tensor: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SendInst> {
        let op = scope.new_operation("Send", |builder| {
            builder.add_input(tensor);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.tensor_name {
                builder.set_attr_string("tensor_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.send_device {
                builder.set_attr_string("send_device", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.send_device_incarnation {
                builder.set_attr_int("send_device_incarnation", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.recv_device {
                builder.set_attr_string("recv_device", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.client_terminated {
                builder.set_attr_bool("client_terminated", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SendInst { op })
    }
}
impl SendInst {
    /// Returns the 'tensor' Input of this 'Send' operation.
    pub fn tensor(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<SendInst> for crate::Operation {
    fn from(inst: SendInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Send::new().build(tensor, scope)`.
pub fn send<O0: ::std::convert::Into<crate::Output>>(
    tensor: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Send::new().build(tensor, scope)
}

/// Builder for the `SendTPUEmbeddingGradients` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SendTPUEmbeddingGradients {
    N: ::std::option::Option<i64>,
    NN: ::std::option::Option<i64>,
    config: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SendTPUEmbeddingGradients' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SendTPUEmbeddingGradientsInst {
    /// An instance of a fully built SendTPUEmbeddingGradients Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SendTPUEmbeddingGradients {
    /// Creates a new `SendTPUEmbeddingGradients`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `N` attribute.
    pub fn N<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.N = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `NN` attribute.
    pub fn NN<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.NN = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `config` attribute.
    pub fn config<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.config = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SendTPUEmbeddingGradients` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        inputs: O0,
        learning_rates: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(inputs.into(), learning_rates.into(), scope)
    }
    fn build_impl(
        &self,
        inputs: crate::Output,
        learning_rates: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SendTPUEmbeddingGradients", |nd| {
            nd.add_input(inputs);
            nd.add_input(learning_rates);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.N {
                nd.set_attr_int("N", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.NN {
                nd.set_attr_int("NN", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.config {
                nd.set_attr_string("config", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SendTPUEmbeddingGradients' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        inputs: Vec<crate::Output>,
        learning_rates: Vec<crate::Output>,
        scope: &mut crate::Scope,
    ) -> crate::Result<SendTPUEmbeddingGradientsInst> {
        let op = scope.new_operation("SendTPUEmbeddingGradients", |builder| {
            builder.add_input_list(&inputs);
            builder.add_input_list(&learning_rates);
            builder.set_attr_int("N", inputs.clone().len() as i64)?;
            builder.set_attr_int("NN", learning_rates.clone().len() as i64)?;
            if let ::std::option::Option::Some(value) = &self.config {
                builder.set_attr_string("config", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SendTPUEmbeddingGradientsInst { op })
    }
}
impl SendTPUEmbeddingGradientsInst {
    /// Returns a Vector of inputs for 'inputs' Input of this SendTPUEmbeddingGradients operation.
    pub fn inputs(&self) -> crate::Result<Vec<crate::Input>> {
        let mut Inputs = vec![];
        for i in 0..self.op.get_attr_int("N")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
    /// Returns a Vector of learning_rates for 'learning_rates' Input of this SendTPUEmbeddingGradients operation.
    pub fn learning_rates(&self) -> crate::Result<Vec<crate::Input>> {
        let dynamic_offset = (self.op.get_attr_int("N")? + 1) as i32;
        let mut Inputs = vec![];
        for i in dynamic_offset..dynamic_offset + self.op.get_attr_int("NN")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
}
impl From<SendTPUEmbeddingGradientsInst> for crate::Operation {
    fn from(inst: SendTPUEmbeddingGradientsInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SendTPUEmbeddingGradients::new().build(inputs, learning_rates, scope)`.
pub fn send_tpuembedding_gradients<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    inputs: O0,
    learning_rates: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SendTPUEmbeddingGradients::new().build(inputs, learning_rates, scope)
}

/// Builder for the `SerializeIterator` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SerializeIterator {
    external_state_policy: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SerializeIterator' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SerializeIteratorInst {
    /// An instance of a fully built SerializeIterator Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SerializeIterator {
    /// Creates a new `SerializeIterator`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `external_state_policy` attribute.
    pub fn external_state_policy<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.external_state_policy = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SerializeIterator` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        resource_handle: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(resource_handle.into(), scope)
    }
    fn build_impl(
        &self,
        resource_handle: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SerializeIterator", |nd| {
            nd.add_input(resource_handle);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.external_state_policy {
                nd.set_attr_int("external_state_policy", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SerializeIterator' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        resource_handle: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SerializeIteratorInst> {
        let op = scope.new_operation("SerializeIterator", |builder| {
            builder.add_input(resource_handle);
            if let ::std::option::Option::Some(value) = &self.external_state_policy {
                builder.set_attr_int("external_state_policy", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SerializeIteratorInst { op })
    }
}
impl SerializeIteratorInst {
    /// Returns the 'serialized' Output of this 'SerializeIterator' operation.
    pub fn serialized(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'resource_handle' Input of this 'SerializeIterator' operation.
    pub fn resource_handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<SerializeIteratorInst> for crate::Operation {
    fn from(inst: SerializeIteratorInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SerializeIterator::new().build(resource_handle, scope)`.
pub fn serialize_iterator<O0: ::std::convert::Into<crate::Output>>(
    resource_handle: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SerializeIterator::new().build(resource_handle, scope)
}

/// Builder for the `SerializeManySparse` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SerializeManySparse {
    T: ::std::option::Option<crate::DataType>,
    out_type: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SerializeManySparse' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SerializeManySparseInst {
    /// An instance of a fully built SerializeManySparse Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SerializeManySparse {
    /// Creates a new `SerializeManySparse`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `out_type` attribute.
    pub fn out_type<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.out_type = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SerializeManySparse` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        sparse_indices: O0,
        sparse_values: O1,
        sparse_shape: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            sparse_indices.into(),
            sparse_values.into(),
            sparse_shape.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        sparse_indices: crate::Output,
        sparse_values: crate::Output,
        sparse_shape: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SerializeManySparse", |nd| {
            nd.add_input(sparse_indices);
            nd.add_input(sparse_values);
            nd.add_input(sparse_shape);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.out_type {
                nd.set_attr_type("out_type", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SerializeManySparse' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        sparse_indices: crate::Output,
        sparse_values: crate::Output,
        sparse_shape: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SerializeManySparseInst> {
        let op = scope.new_operation("SerializeManySparse", |builder| {
            builder.add_input(sparse_indices);
            builder.add_input(sparse_values);
            builder.add_input(sparse_shape);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.out_type {
                builder.set_attr_type("out_type", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SerializeManySparseInst { op })
    }
}
impl SerializeManySparseInst {
    /// Returns the 'serialized_sparse' Output of this 'SerializeManySparse' operation.
    pub fn serialized_sparse(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'sparse_indices' Input of this 'SerializeManySparse' operation.
    pub fn sparse_indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'sparse_values' Input of this 'SerializeManySparse' operation.
    pub fn sparse_values(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'sparse_shape' Input of this 'SerializeManySparse' operation.
    pub fn sparse_shape(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<SerializeManySparseInst> for crate::Operation {
    fn from(inst: SerializeManySparseInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SerializeManySparse::new().build(sparse_indices, sparse_values, sparse_shape, scope)`.
pub fn serialize_many_sparse<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    sparse_indices: O0,
    sparse_values: O1,
    sparse_shape: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SerializeManySparse::new().build(sparse_indices, sparse_values, sparse_shape, scope)
}

/// Builder for the `SerializeSparse` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SerializeSparse {
    T: ::std::option::Option<crate::DataType>,
    out_type: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SerializeSparse' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SerializeSparseInst {
    /// An instance of a fully built SerializeSparse Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SerializeSparse {
    /// Creates a new `SerializeSparse`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `out_type` attribute.
    pub fn out_type<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.out_type = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SerializeSparse` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        sparse_indices: O0,
        sparse_values: O1,
        sparse_shape: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            sparse_indices.into(),
            sparse_values.into(),
            sparse_shape.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        sparse_indices: crate::Output,
        sparse_values: crate::Output,
        sparse_shape: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SerializeSparse", |nd| {
            nd.add_input(sparse_indices);
            nd.add_input(sparse_values);
            nd.add_input(sparse_shape);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.out_type {
                nd.set_attr_type("out_type", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SerializeSparse' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        sparse_indices: crate::Output,
        sparse_values: crate::Output,
        sparse_shape: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SerializeSparseInst> {
        let op = scope.new_operation("SerializeSparse", |builder| {
            builder.add_input(sparse_indices);
            builder.add_input(sparse_values);
            builder.add_input(sparse_shape);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.out_type {
                builder.set_attr_type("out_type", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SerializeSparseInst { op })
    }
}
impl SerializeSparseInst {
    /// Returns the 'serialized_sparse' Output of this 'SerializeSparse' operation.
    pub fn serialized_sparse(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'sparse_indices' Input of this 'SerializeSparse' operation.
    pub fn sparse_indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'sparse_values' Input of this 'SerializeSparse' operation.
    pub fn sparse_values(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'sparse_shape' Input of this 'SerializeSparse' operation.
    pub fn sparse_shape(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<SerializeSparseInst> for crate::Operation {
    fn from(inst: SerializeSparseInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SerializeSparse::new().build(sparse_indices, sparse_values, sparse_shape, scope)`.
pub fn serialize_sparse<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    sparse_indices: O0,
    sparse_values: O1,
    sparse_shape: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SerializeSparse::new().build(sparse_indices, sparse_values, sparse_shape, scope)
}

/// Builder for the `SerializeTensor` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SerializeTensor {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SerializeTensor' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SerializeTensorInst {
    /// An instance of a fully built SerializeTensor Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SerializeTensor {
    /// Creates a new `SerializeTensor`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SerializeTensor` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        tensor: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(tensor.into(), scope)
    }
    fn build_impl(
        &self,
        tensor: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SerializeTensor", |nd| {
            nd.add_input(tensor);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SerializeTensor' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        tensor: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SerializeTensorInst> {
        let op = scope.new_operation("SerializeTensor", |builder| {
            builder.add_input(tensor);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SerializeTensorInst { op })
    }
}
impl SerializeTensorInst {
    /// Returns the 'serialized' Output of this 'SerializeTensor' operation.
    pub fn serialized(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'tensor' Input of this 'SerializeTensor' operation.
    pub fn tensor(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<SerializeTensorInst> for crate::Operation {
    fn from(inst: SerializeTensorInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SerializeTensor::new().build(tensor, scope)`.
pub fn serialize_tensor<O0: ::std::convert::Into<crate::Output>>(
    tensor: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SerializeTensor::new().build(tensor, scope)
}

/// Builder for the `SetSize` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SetSize {
    validate_indices: ::std::option::Option<bool>,
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SetSize' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SetSizeInst {
    /// An instance of a fully built SetSize Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SetSize {
    /// Creates a new `SetSize`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `validate_indices` attribute.
    pub fn validate_indices<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.validate_indices = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SetSize` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        set_indices: O0,
        set_values: O1,
        set_shape: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            set_indices.into(),
            set_values.into(),
            set_shape.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        set_indices: crate::Output,
        set_values: crate::Output,
        set_shape: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SetSize", |nd| {
            nd.add_input(set_indices);
            nd.add_input(set_values);
            nd.add_input(set_shape);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.validate_indices {
                nd.set_attr_bool("validate_indices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SetSize' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        set_indices: crate::Output,
        set_values: crate::Output,
        set_shape: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SetSizeInst> {
        let op = scope.new_operation("SetSize", |builder| {
            builder.add_input(set_indices);
            builder.add_input(set_values);
            builder.add_input(set_shape);
            if let ::std::option::Option::Some(value) = &self.validate_indices {
                builder.set_attr_bool("validate_indices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SetSizeInst { op })
    }
}
impl SetSizeInst {
    /// Returns the 'size' Output of this 'SetSize' operation.
    pub fn size(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'set_indices' Input of this 'SetSize' operation.
    pub fn set_indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'set_values' Input of this 'SetSize' operation.
    pub fn set_values(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'set_shape' Input of this 'SetSize' operation.
    pub fn set_shape(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<SetSizeInst> for crate::Operation {
    fn from(inst: SetSizeInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SetSize::new().build(set_indices, set_values, set_shape, scope)`.
pub fn set_size<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    set_indices: O0,
    set_values: O1,
    set_shape: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SetSize::new().build(set_indices, set_values, set_shape, scope)
}

/// Builder for the `SetStatsAggregatorDataset` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SetStatsAggregatorDataset {
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SetStatsAggregatorDataset' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SetStatsAggregatorDatasetInst {
    /// An instance of a fully built SetStatsAggregatorDataset Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SetStatsAggregatorDataset {
    /// Creates a new `SetStatsAggregatorDataset`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SetStatsAggregatorDataset` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input_dataset: O0,
        stats_aggregator: O1,
        tag: O2,
        counter_prefix: O3,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            input_dataset.into(),
            stats_aggregator.into(),
            tag.into(),
            counter_prefix.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        input_dataset: crate::Output,
        stats_aggregator: crate::Output,
        tag: crate::Output,
        counter_prefix: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SetStatsAggregatorDataset", |nd| {
            nd.add_input(input_dataset);
            nd.add_input(stats_aggregator);
            nd.add_input(tag);
            nd.add_input(counter_prefix);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SetStatsAggregatorDataset' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_dataset: crate::Output,
        stats_aggregator: crate::Output,
        tag: crate::Output,
        counter_prefix: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SetStatsAggregatorDatasetInst> {
        let op = scope.new_operation("SetStatsAggregatorDataset", |builder| {
            builder.add_input(input_dataset);
            builder.add_input(stats_aggregator);
            builder.add_input(tag);
            builder.add_input(counter_prefix);
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SetStatsAggregatorDatasetInst { op })
    }
}
impl SetStatsAggregatorDatasetInst {
    /// Returns the 'handle' Output of this 'SetStatsAggregatorDataset' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_dataset' Input of this 'SetStatsAggregatorDataset' operation.
    pub fn input_dataset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'stats_aggregator' Input of this 'SetStatsAggregatorDataset' operation.
    pub fn stats_aggregator(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'tag' Input of this 'SetStatsAggregatorDataset' operation.
    pub fn tag(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'counter_prefix' Input of this 'SetStatsAggregatorDataset' operation.
    pub fn counter_prefix(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
}
impl From<SetStatsAggregatorDatasetInst> for crate::Operation {
    fn from(inst: SetStatsAggregatorDatasetInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SetStatsAggregatorDataset::new().build(input_dataset, stats_aggregator, tag, counter_prefix, scope)`.
pub fn set_stats_aggregator_dataset<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
>(
    input_dataset: O0,
    stats_aggregator: O1,
    tag: O2,
    counter_prefix: O3,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SetStatsAggregatorDataset::new().build(
        input_dataset,
        stats_aggregator,
        tag,
        counter_prefix,
        scope,
    )
}

/// Builder for the `Shape` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Shape {
    T: ::std::option::Option<crate::DataType>,
    out_type: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Shape' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ShapeInst {
    /// An instance of a fully built Shape Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Shape {
    /// Creates a new `Shape`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `out_type` attribute.
    pub fn out_type<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.out_type = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Shape` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Shape", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.out_type {
                nd.set_attr_type("out_type", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Shape' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ShapeInst> {
        let op = scope.new_operation("Shape", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.out_type {
                builder.set_attr_type("out_type", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ShapeInst { op })
    }
}
impl ShapeInst {
    /// Returns the 'output' Output of this 'Shape' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'Shape' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<ShapeInst> for crate::Operation {
    fn from(inst: ShapeInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Shape::new().build(input, scope)`.
pub fn shape<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Shape::new().build(input, scope)
}

/// Builder for the `ShapeN` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ShapeN {
    N: ::std::option::Option<i64>,
    T: ::std::option::Option<crate::DataType>,
    out_type: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ShapeN' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ShapeNInst {
    /// An instance of a fully built ShapeN Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ShapeN {
    /// Creates a new `ShapeN`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `N` attribute.
    pub fn N<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.N = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `out_type` attribute.
    pub fn out_type<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.out_type = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ShapeN` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ShapeN", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.N {
                nd.set_attr_int("N", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.out_type {
                nd.set_attr_type("out_type", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ShapeN' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: Vec<crate::Output>,
        scope: &mut crate::Scope,
    ) -> crate::Result<ShapeNInst> {
        let op = scope.new_operation("ShapeN", |builder| {
            builder.add_input_list(&input);
            builder.set_attr_int("N", input.clone().len() as i64)?;
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.out_type {
                builder.set_attr_type("out_type", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ShapeNInst { op })
    }
}
impl ShapeNInst {
    /// Returns a Vector of output for 'output' Output of this ShapeN operation.
    pub fn output(&self) -> crate::Result<Vec<crate::Output>> {
        let mut Outputs = vec![];
        for i in 0..self.op.get_attr_int("N")? as i32 {
            Outputs.push(crate::Output {
                operation: self.op.clone(),
                index: i,
            });
        }
        Ok(Outputs)
    }
    /// Returns a Vector of input for 'input' Input of this ShapeN operation.
    pub fn input(&self) -> crate::Result<Vec<crate::Input>> {
        let mut Inputs = vec![];
        for i in 0..self.op.get_attr_int("N")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
}
impl From<ShapeNInst> for crate::Operation {
    fn from(inst: ShapeNInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ShapeN::new().build(input, scope)`.
pub fn shape_n<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ShapeN::new().build(input, scope)
}

/// Builder for the `ShardDataset` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ShardDataset {
    require_non_empty: ::std::option::Option<bool>,
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    metadata: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ShardDataset' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ShardDatasetInst {
    /// An instance of a fully built ShardDataset Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ShardDataset {
    /// Creates a new `ShardDataset`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `require_non_empty` attribute.
    pub fn require_non_empty<ArgType: ::std::convert::Into<bool>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.require_non_empty = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `metadata` attribute.
    pub fn metadata<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.metadata = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ShardDataset` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input_dataset: O0,
        num_shards: O1,
        index: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input_dataset.into(), num_shards.into(), index.into(), scope)
    }
    fn build_impl(
        &self,
        input_dataset: crate::Output,
        num_shards: crate::Output,
        index: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ShardDataset", |nd| {
            nd.add_input(input_dataset);
            nd.add_input(num_shards);
            nd.add_input(index);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.require_non_empty {
                nd.set_attr_bool("require_non_empty", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.metadata {
                nd.set_attr_string("metadata", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ShardDataset' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_dataset: crate::Output,
        num_shards: crate::Output,
        index: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ShardDatasetInst> {
        let op = scope.new_operation("ShardDataset", |builder| {
            builder.add_input(input_dataset);
            builder.add_input(num_shards);
            builder.add_input(index);
            if let ::std::option::Option::Some(value) = &self.require_non_empty {
                builder.set_attr_bool("require_non_empty", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.metadata {
                builder.set_attr_string("metadata", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ShardDatasetInst { op })
    }
}
impl ShardDatasetInst {
    /// Returns the 'handle' Output of this 'ShardDataset' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_dataset' Input of this 'ShardDataset' operation.
    pub fn input_dataset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'num_shards' Input of this 'ShardDataset' operation.
    pub fn num_shards(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'index' Input of this 'ShardDataset' operation.
    pub fn index(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<ShardDatasetInst> for crate::Operation {
    fn from(inst: ShardDatasetInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ShardDataset::new().build(input_dataset, num_shards, index, scope)`.
pub fn shard_dataset<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    input_dataset: O0,
    num_shards: O1,
    index: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ShardDataset::new().build(input_dataset, num_shards, index, scope)
}

/// Builder for the `ShardedFilename` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ShardedFilename {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ShardedFilename' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ShardedFilenameInst {
    /// An instance of a fully built ShardedFilename Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ShardedFilename {
    /// Creates a new `ShardedFilename`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ShardedFilename` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        basename: O0,
        shard: O1,
        num_shards: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(basename.into(), shard.into(), num_shards.into(), scope)
    }
    fn build_impl(
        &self,
        basename: crate::Output,
        shard: crate::Output,
        num_shards: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ShardedFilename", |nd| {
            nd.add_input(basename);
            nd.add_input(shard);
            nd.add_input(num_shards);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ShardedFilename' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        basename: crate::Output,
        shard: crate::Output,
        num_shards: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ShardedFilenameInst> {
        let op = scope.new_operation("ShardedFilename", |builder| {
            builder.add_input(basename);
            builder.add_input(shard);
            builder.add_input(num_shards);
            ::std::result::Result::Ok(())
        })?;
        Ok(ShardedFilenameInst { op })
    }
}
impl ShardedFilenameInst {
    /// Returns the 'filename' Output of this 'ShardedFilename' operation.
    pub fn filename(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'basename' Input of this 'ShardedFilename' operation.
    pub fn basename(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'shard' Input of this 'ShardedFilename' operation.
    pub fn shard(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'num_shards' Input of this 'ShardedFilename' operation.
    pub fn num_shards(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<ShardedFilenameInst> for crate::Operation {
    fn from(inst: ShardedFilenameInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ShardedFilename::new().build(basename, shard, num_shards, scope)`.
pub fn sharded_filename<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    basename: O0,
    shard: O1,
    num_shards: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ShardedFilename::new().build(basename, shard, num_shards, scope)
}

/// Builder for the `ShardedFilespec` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ShardedFilespec {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ShardedFilespec' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ShardedFilespecInst {
    /// An instance of a fully built ShardedFilespec Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ShardedFilespec {
    /// Creates a new `ShardedFilespec`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ShardedFilespec` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        basename: O0,
        num_shards: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(basename.into(), num_shards.into(), scope)
    }
    fn build_impl(
        &self,
        basename: crate::Output,
        num_shards: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ShardedFilespec", |nd| {
            nd.add_input(basename);
            nd.add_input(num_shards);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ShardedFilespec' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        basename: crate::Output,
        num_shards: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ShardedFilespecInst> {
        let op = scope.new_operation("ShardedFilespec", |builder| {
            builder.add_input(basename);
            builder.add_input(num_shards);
            ::std::result::Result::Ok(())
        })?;
        Ok(ShardedFilespecInst { op })
    }
}
impl ShardedFilespecInst {
    /// Returns the 'filename' Output of this 'ShardedFilespec' operation.
    pub fn filename(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'basename' Input of this 'ShardedFilespec' operation.
    pub fn basename(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'num_shards' Input of this 'ShardedFilespec' operation.
    pub fn num_shards(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<ShardedFilespecInst> for crate::Operation {
    fn from(inst: ShardedFilespecInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ShardedFilespec::new().build(basename, num_shards, scope)`.
pub fn sharded_filespec<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    basename: O0,
    num_shards: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ShardedFilespec::new().build(basename, num_shards, scope)
}

/// Builder for the `ShuffleAndRepeatDataset` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ShuffleAndRepeatDataset {
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    reshuffle_each_iteration: ::std::option::Option<bool>,
    metadata: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ShuffleAndRepeatDataset' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ShuffleAndRepeatDatasetInst {
    /// An instance of a fully built ShuffleAndRepeatDataset Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ShuffleAndRepeatDataset {
    /// Creates a new `ShuffleAndRepeatDataset`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `reshuffle_each_iteration` attribute.
    pub fn reshuffle_each_iteration<ArgType: ::std::convert::Into<bool>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.reshuffle_each_iteration = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `metadata` attribute.
    pub fn metadata<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.metadata = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ShuffleAndRepeatDataset` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input_dataset: O0,
        buffer_size: O1,
        seed: O2,
        seed2: O3,
        count: O4,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            input_dataset.into(),
            buffer_size.into(),
            seed.into(),
            seed2.into(),
            count.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        input_dataset: crate::Output,
        buffer_size: crate::Output,
        seed: crate::Output,
        seed2: crate::Output,
        count: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ShuffleAndRepeatDataset", |nd| {
            nd.add_input(input_dataset);
            nd.add_input(buffer_size);
            nd.add_input(seed);
            nd.add_input(seed2);
            nd.add_input(count);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.reshuffle_each_iteration {
                nd.set_attr_bool("reshuffle_each_iteration", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.metadata {
                nd.set_attr_string("metadata", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ShuffleAndRepeatDataset' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_dataset: crate::Output,
        buffer_size: crate::Output,
        seed: crate::Output,
        seed2: crate::Output,
        count: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ShuffleAndRepeatDatasetInst> {
        let op = scope.new_operation("ShuffleAndRepeatDataset", |builder| {
            builder.add_input(input_dataset);
            builder.add_input(buffer_size);
            builder.add_input(seed);
            builder.add_input(seed2);
            builder.add_input(count);
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.reshuffle_each_iteration {
                builder.set_attr_bool("reshuffle_each_iteration", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.metadata {
                builder.set_attr_string("metadata", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ShuffleAndRepeatDatasetInst { op })
    }
}
impl ShuffleAndRepeatDatasetInst {
    /// Returns the 'handle' Output of this 'ShuffleAndRepeatDataset' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_dataset' Input of this 'ShuffleAndRepeatDataset' operation.
    pub fn input_dataset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'buffer_size' Input of this 'ShuffleAndRepeatDataset' operation.
    pub fn buffer_size(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'seed' Input of this 'ShuffleAndRepeatDataset' operation.
    pub fn seed(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'seed2' Input of this 'ShuffleAndRepeatDataset' operation.
    pub fn seed2(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'count' Input of this 'ShuffleAndRepeatDataset' operation.
    pub fn count(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
}
impl From<ShuffleAndRepeatDatasetInst> for crate::Operation {
    fn from(inst: ShuffleAndRepeatDatasetInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ShuffleAndRepeatDataset::new().build(input_dataset, buffer_size, seed, seed2, count, scope)`.
pub fn shuffle_and_repeat_dataset<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
>(
    input_dataset: O0,
    buffer_size: O1,
    seed: O2,
    seed2: O3,
    count: O4,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ShuffleAndRepeatDataset::new().build(input_dataset, buffer_size, seed, seed2, count, scope)
}

/// Builder for the `ShuffleAndRepeatDatasetV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ShuffleAndRepeatDatasetV2 {
    reshuffle_each_iteration: ::std::option::Option<bool>,
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    metadata: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ShuffleAndRepeatDatasetV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ShuffleAndRepeatDatasetV2Inst {
    /// An instance of a fully built ShuffleAndRepeatDatasetV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ShuffleAndRepeatDatasetV2 {
    /// Creates a new `ShuffleAndRepeatDatasetV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `reshuffle_each_iteration` attribute.
    pub fn reshuffle_each_iteration<ArgType: ::std::convert::Into<bool>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.reshuffle_each_iteration = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `metadata` attribute.
    pub fn metadata<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.metadata = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ShuffleAndRepeatDatasetV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input_dataset: O0,
        buffer_size: O1,
        seed: O2,
        seed2: O3,
        count: O4,
        seed_generator: O5,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            input_dataset.into(),
            buffer_size.into(),
            seed.into(),
            seed2.into(),
            count.into(),
            seed_generator.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        input_dataset: crate::Output,
        buffer_size: crate::Output,
        seed: crate::Output,
        seed2: crate::Output,
        count: crate::Output,
        seed_generator: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ShuffleAndRepeatDatasetV2", |nd| {
            nd.add_input(input_dataset);
            nd.add_input(buffer_size);
            nd.add_input(seed);
            nd.add_input(seed2);
            nd.add_input(count);
            nd.add_input(seed_generator);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.reshuffle_each_iteration {
                nd.set_attr_bool("reshuffle_each_iteration", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.metadata {
                nd.set_attr_string("metadata", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ShuffleAndRepeatDatasetV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_dataset: crate::Output,
        buffer_size: crate::Output,
        seed: crate::Output,
        seed2: crate::Output,
        count: crate::Output,
        seed_generator: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ShuffleAndRepeatDatasetV2Inst> {
        let op = scope.new_operation("ShuffleAndRepeatDatasetV2", |builder| {
            builder.add_input(input_dataset);
            builder.add_input(buffer_size);
            builder.add_input(seed);
            builder.add_input(seed2);
            builder.add_input(count);
            builder.add_input(seed_generator);
            if let ::std::option::Option::Some(value) = &self.reshuffle_each_iteration {
                builder.set_attr_bool("reshuffle_each_iteration", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.metadata {
                builder.set_attr_string("metadata", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ShuffleAndRepeatDatasetV2Inst { op })
    }
}
impl ShuffleAndRepeatDatasetV2Inst {
    /// Returns the 'handle' Output of this 'ShuffleAndRepeatDatasetV2' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_dataset' Input of this 'ShuffleAndRepeatDatasetV2' operation.
    pub fn input_dataset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'buffer_size' Input of this 'ShuffleAndRepeatDatasetV2' operation.
    pub fn buffer_size(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'seed' Input of this 'ShuffleAndRepeatDatasetV2' operation.
    pub fn seed(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'seed2' Input of this 'ShuffleAndRepeatDatasetV2' operation.
    pub fn seed2(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'count' Input of this 'ShuffleAndRepeatDatasetV2' operation.
    pub fn count(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
    /// Returns the 'seed_generator' Input of this 'ShuffleAndRepeatDatasetV2' operation.
    pub fn seed_generator(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 5,
        }
    }
}
impl From<ShuffleAndRepeatDatasetV2Inst> for crate::Operation {
    fn from(inst: ShuffleAndRepeatDatasetV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ShuffleAndRepeatDatasetV2::new().build(input_dataset, buffer_size, seed, seed2, count, seed_generator, scope)`.
pub fn shuffle_and_repeat_dataset_v2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
>(
    input_dataset: O0,
    buffer_size: O1,
    seed: O2,
    seed2: O3,
    count: O4,
    seed_generator: O5,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ShuffleAndRepeatDatasetV2::new().build(
        input_dataset,
        buffer_size,
        seed,
        seed2,
        count,
        seed_generator,
        scope,
    )
}

/// Builder for the `ShuffleDataset` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ShuffleDataset {
    reshuffle_each_iteration: ::std::option::Option<bool>,
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    metadata: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ShuffleDataset' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ShuffleDatasetInst {
    /// An instance of a fully built ShuffleDataset Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ShuffleDataset {
    /// Creates a new `ShuffleDataset`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `reshuffle_each_iteration` attribute.
    pub fn reshuffle_each_iteration<ArgType: ::std::convert::Into<bool>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.reshuffle_each_iteration = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `metadata` attribute.
    pub fn metadata<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.metadata = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ShuffleDataset` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input_dataset: O0,
        buffer_size: O1,
        seed: O2,
        seed2: O3,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            input_dataset.into(),
            buffer_size.into(),
            seed.into(),
            seed2.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        input_dataset: crate::Output,
        buffer_size: crate::Output,
        seed: crate::Output,
        seed2: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ShuffleDataset", |nd| {
            nd.add_input(input_dataset);
            nd.add_input(buffer_size);
            nd.add_input(seed);
            nd.add_input(seed2);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.reshuffle_each_iteration {
                nd.set_attr_bool("reshuffle_each_iteration", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.metadata {
                nd.set_attr_string("metadata", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ShuffleDataset' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_dataset: crate::Output,
        buffer_size: crate::Output,
        seed: crate::Output,
        seed2: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ShuffleDatasetInst> {
        let op = scope.new_operation("ShuffleDataset", |builder| {
            builder.add_input(input_dataset);
            builder.add_input(buffer_size);
            builder.add_input(seed);
            builder.add_input(seed2);
            if let ::std::option::Option::Some(value) = &self.reshuffle_each_iteration {
                builder.set_attr_bool("reshuffle_each_iteration", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.metadata {
                builder.set_attr_string("metadata", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ShuffleDatasetInst { op })
    }
}
impl ShuffleDatasetInst {
    /// Returns the 'handle' Output of this 'ShuffleDataset' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_dataset' Input of this 'ShuffleDataset' operation.
    pub fn input_dataset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'buffer_size' Input of this 'ShuffleDataset' operation.
    pub fn buffer_size(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'seed' Input of this 'ShuffleDataset' operation.
    pub fn seed(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'seed2' Input of this 'ShuffleDataset' operation.
    pub fn seed2(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
}
impl From<ShuffleDatasetInst> for crate::Operation {
    fn from(inst: ShuffleDatasetInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ShuffleDataset::new().build(input_dataset, buffer_size, seed, seed2, scope)`.
pub fn shuffle_dataset<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
>(
    input_dataset: O0,
    buffer_size: O1,
    seed: O2,
    seed2: O3,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ShuffleDataset::new().build(input_dataset, buffer_size, seed, seed2, scope)
}

/// Builder for the `ShuffleDatasetV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ShuffleDatasetV2 {
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    metadata: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ShuffleDatasetV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ShuffleDatasetV2Inst {
    /// An instance of a fully built ShuffleDatasetV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ShuffleDatasetV2 {
    /// Creates a new `ShuffleDatasetV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `metadata` attribute.
    pub fn metadata<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.metadata = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ShuffleDatasetV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input_dataset: O0,
        buffer_size: O1,
        seed_generator: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            input_dataset.into(),
            buffer_size.into(),
            seed_generator.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        input_dataset: crate::Output,
        buffer_size: crate::Output,
        seed_generator: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ShuffleDatasetV2", |nd| {
            nd.add_input(input_dataset);
            nd.add_input(buffer_size);
            nd.add_input(seed_generator);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.metadata {
                nd.set_attr_string("metadata", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ShuffleDatasetV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_dataset: crate::Output,
        buffer_size: crate::Output,
        seed_generator: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ShuffleDatasetV2Inst> {
        let op = scope.new_operation("ShuffleDatasetV2", |builder| {
            builder.add_input(input_dataset);
            builder.add_input(buffer_size);
            builder.add_input(seed_generator);
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.metadata {
                builder.set_attr_string("metadata", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ShuffleDatasetV2Inst { op })
    }
}
impl ShuffleDatasetV2Inst {
    /// Returns the 'handle' Output of this 'ShuffleDatasetV2' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_dataset' Input of this 'ShuffleDatasetV2' operation.
    pub fn input_dataset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'buffer_size' Input of this 'ShuffleDatasetV2' operation.
    pub fn buffer_size(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'seed_generator' Input of this 'ShuffleDatasetV2' operation.
    pub fn seed_generator(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<ShuffleDatasetV2Inst> for crate::Operation {
    fn from(inst: ShuffleDatasetV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ShuffleDatasetV2::new().build(input_dataset, buffer_size, seed_generator, scope)`.
pub fn shuffle_dataset_v2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    input_dataset: O0,
    buffer_size: O1,
    seed_generator: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ShuffleDatasetV2::new().build(input_dataset, buffer_size, seed_generator, scope)
}

/// Builder for the `ShuffleDatasetV3` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ShuffleDatasetV3 {
    reshuffle_each_iteration: ::std::option::Option<bool>,
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    metadata: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ShuffleDatasetV3' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ShuffleDatasetV3Inst {
    /// An instance of a fully built ShuffleDatasetV3 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ShuffleDatasetV3 {
    /// Creates a new `ShuffleDatasetV3`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `reshuffle_each_iteration` attribute.
    pub fn reshuffle_each_iteration<ArgType: ::std::convert::Into<bool>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.reshuffle_each_iteration = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `metadata` attribute.
    pub fn metadata<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.metadata = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ShuffleDatasetV3` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input_dataset: O0,
        buffer_size: O1,
        seed: O2,
        seed2: O3,
        seed_generator: O4,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            input_dataset.into(),
            buffer_size.into(),
            seed.into(),
            seed2.into(),
            seed_generator.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        input_dataset: crate::Output,
        buffer_size: crate::Output,
        seed: crate::Output,
        seed2: crate::Output,
        seed_generator: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ShuffleDatasetV3", |nd| {
            nd.add_input(input_dataset);
            nd.add_input(buffer_size);
            nd.add_input(seed);
            nd.add_input(seed2);
            nd.add_input(seed_generator);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.reshuffle_each_iteration {
                nd.set_attr_bool("reshuffle_each_iteration", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.metadata {
                nd.set_attr_string("metadata", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ShuffleDatasetV3' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_dataset: crate::Output,
        buffer_size: crate::Output,
        seed: crate::Output,
        seed2: crate::Output,
        seed_generator: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ShuffleDatasetV3Inst> {
        let op = scope.new_operation("ShuffleDatasetV3", |builder| {
            builder.add_input(input_dataset);
            builder.add_input(buffer_size);
            builder.add_input(seed);
            builder.add_input(seed2);
            builder.add_input(seed_generator);
            if let ::std::option::Option::Some(value) = &self.reshuffle_each_iteration {
                builder.set_attr_bool("reshuffle_each_iteration", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.metadata {
                builder.set_attr_string("metadata", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ShuffleDatasetV3Inst { op })
    }
}
impl ShuffleDatasetV3Inst {
    /// Returns the 'handle' Output of this 'ShuffleDatasetV3' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_dataset' Input of this 'ShuffleDatasetV3' operation.
    pub fn input_dataset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'buffer_size' Input of this 'ShuffleDatasetV3' operation.
    pub fn buffer_size(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'seed' Input of this 'ShuffleDatasetV3' operation.
    pub fn seed(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'seed2' Input of this 'ShuffleDatasetV3' operation.
    pub fn seed2(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'seed_generator' Input of this 'ShuffleDatasetV3' operation.
    pub fn seed_generator(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
}
impl From<ShuffleDatasetV3Inst> for crate::Operation {
    fn from(inst: ShuffleDatasetV3Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ShuffleDatasetV3::new().build(input_dataset, buffer_size, seed, seed2, seed_generator, scope)`.
pub fn shuffle_dataset_v3<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
>(
    input_dataset: O0,
    buffer_size: O1,
    seed: O2,
    seed2: O3,
    seed_generator: O4,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ShuffleDatasetV3::new().build(
        input_dataset,
        buffer_size,
        seed,
        seed2,
        seed_generator,
        scope,
    )
}

/// Builder for the `ShutdownDistributedTPU` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ShutdownDistributedTPU {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ShutdownDistributedTPU' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ShutdownDistributedTPUInst {
    /// An instance of a fully built ShutdownDistributedTPU Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ShutdownDistributedTPU {
    /// Creates a new `ShutdownDistributedTPU`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ShutdownDistributedTPU` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("ShutdownDistributedTPU", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ShutdownDistributedTPU' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        scope: &mut crate::Scope,
    ) -> crate::Result<ShutdownDistributedTPUInst> {
        let op = scope.new_operation("ShutdownDistributedTPU", |builder| {
            ::std::result::Result::Ok(())
        })?;
        Ok(ShutdownDistributedTPUInst { op })
    }
}
impl ShutdownDistributedTPUInst {}
impl From<ShutdownDistributedTPUInst> for crate::Operation {
    fn from(inst: ShutdownDistributedTPUInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ShutdownDistributedTPU::new().build(scope)`.
pub fn shutdown_distributed_tpu(scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
    ShutdownDistributedTPU::new().build(scope)
}

/// Builder for the `ShutdownTPUSystem` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ShutdownTPUSystem {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ShutdownTPUSystem' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ShutdownTPUSystemInst {
    /// An instance of a fully built ShutdownTPUSystem Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ShutdownTPUSystem {
    /// Creates a new `ShutdownTPUSystem`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ShutdownTPUSystem` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("ShutdownTPUSystem", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ShutdownTPUSystem' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(&self, scope: &mut crate::Scope) -> crate::Result<ShutdownTPUSystemInst> {
        let op =
            scope.new_operation("ShutdownTPUSystem", |builder| ::std::result::Result::Ok(()))?;
        Ok(ShutdownTPUSystemInst { op })
    }
}
impl ShutdownTPUSystemInst {
    /// Returns the 'success' Output of this 'ShutdownTPUSystem' operation.
    pub fn success(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
}
impl From<ShutdownTPUSystemInst> for crate::Operation {
    fn from(inst: ShutdownTPUSystemInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ShutdownTPUSystem::new().build(scope)`.
pub fn shutdown_tpusystem(scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
    ShutdownTPUSystem::new().build(scope)
}

/// Builder for the `Sigmoid` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Sigmoid {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Sigmoid' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SigmoidInst {
    /// An instance of a fully built Sigmoid Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Sigmoid {
    /// Creates a new `Sigmoid`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Sigmoid` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        x: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Sigmoid", |nd| {
            nd.add_input(x);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Sigmoid' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SigmoidInst> {
        let op = scope.new_operation("Sigmoid", |builder| {
            builder.add_input(x);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SigmoidInst { op })
    }
}
impl SigmoidInst {
    /// Returns the 'y' Output of this 'Sigmoid' operation.
    pub fn y(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'Sigmoid' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<SigmoidInst> for crate::Operation {
    fn from(inst: SigmoidInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Sigmoid::new().build(x, scope)`.
pub fn sigmoid<O0: ::std::convert::Into<crate::Output>>(
    x: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Sigmoid::new().build(x, scope)
}

/// Builder for the `SigmoidGrad` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SigmoidGrad {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SigmoidGrad' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SigmoidGradInst {
    /// An instance of a fully built SigmoidGrad Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SigmoidGrad {
    /// Creates a new `SigmoidGrad`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SigmoidGrad` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        y: O0,
        dy: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(y.into(), dy.into(), scope)
    }
    fn build_impl(
        &self,
        y: crate::Output,
        dy: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SigmoidGrad", |nd| {
            nd.add_input(y);
            nd.add_input(dy);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SigmoidGrad' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        y: crate::Output,
        dy: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SigmoidGradInst> {
        let op = scope.new_operation("SigmoidGrad", |builder| {
            builder.add_input(y);
            builder.add_input(dy);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SigmoidGradInst { op })
    }
}
impl SigmoidGradInst {
    /// Returns the 'z' Output of this 'SigmoidGrad' operation.
    pub fn z(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'y' Input of this 'SigmoidGrad' operation.
    pub fn y(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'dy' Input of this 'SigmoidGrad' operation.
    pub fn dy(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<SigmoidGradInst> for crate::Operation {
    fn from(inst: SigmoidGradInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SigmoidGrad::new().build(y, dy, scope)`.
pub fn sigmoid_grad<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    y: O0,
    dy: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SigmoidGrad::new().build(y, dy, scope)
}

/// Builder for the `Sign` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Sign {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Sign' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SignInst {
    /// An instance of a fully built Sign Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Sign {
    /// Creates a new `Sign`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Sign` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        x: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Sign", |nd| {
            nd.add_input(x);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Sign' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SignInst> {
        let op = scope.new_operation("Sign", |builder| {
            builder.add_input(x);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SignInst { op })
    }
}
impl SignInst {
    /// Returns the 'y' Output of this 'Sign' operation.
    pub fn y(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'Sign' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<SignInst> for crate::Operation {
    fn from(inst: SignInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Sign::new().build(x, scope)`.
pub fn sign<O0: ::std::convert::Into<crate::Output>>(
    x: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Sign::new().build(x, scope)
}

/// Builder for the `Sin` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Sin {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Sin' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SinInst {
    /// An instance of a fully built Sin Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Sin {
    /// Creates a new `Sin`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Sin` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        x: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Sin", |nd| {
            nd.add_input(x);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Sin' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SinInst> {
        let op = scope.new_operation("Sin", |builder| {
            builder.add_input(x);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SinInst { op })
    }
}
impl SinInst {
    /// Returns the 'y' Output of this 'Sin' operation.
    pub fn y(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'Sin' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<SinInst> for crate::Operation {
    fn from(inst: SinInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Sin::new().build(x, scope)`.
pub fn sin<O0: ::std::convert::Into<crate::Output>>(
    x: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Sin::new().build(x, scope)
}

/// Builder for the `Sinh` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Sinh {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Sinh' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SinhInst {
    /// An instance of a fully built Sinh Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Sinh {
    /// Creates a new `Sinh`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Sinh` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        x: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Sinh", |nd| {
            nd.add_input(x);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Sinh' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SinhInst> {
        let op = scope.new_operation("Sinh", |builder| {
            builder.add_input(x);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SinhInst { op })
    }
}
impl SinhInst {
    /// Returns the 'y' Output of this 'Sinh' operation.
    pub fn y(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'Sinh' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<SinhInst> for crate::Operation {
    fn from(inst: SinhInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Sinh::new().build(x, scope)`.
pub fn sinh<O0: ::std::convert::Into<crate::Output>>(
    x: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Sinh::new().build(x, scope)
}

/// Builder for the `Size` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Size {
    T: ::std::option::Option<crate::DataType>,
    out_type: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Size' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SizeInst {
    /// An instance of a fully built Size Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Size {
    /// Creates a new `Size`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `out_type` attribute.
    pub fn out_type<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.out_type = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Size` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Size", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.out_type {
                nd.set_attr_type("out_type", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Size' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SizeInst> {
        let op = scope.new_operation("Size", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.out_type {
                builder.set_attr_type("out_type", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SizeInst { op })
    }
}
impl SizeInst {
    /// Returns the 'output' Output of this 'Size' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'Size' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<SizeInst> for crate::Operation {
    fn from(inst: SizeInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Size::new().build(input, scope)`.
pub fn size<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Size::new().build(input, scope)
}

/// Builder for the `SkipDataset` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SkipDataset {
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    metadata: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SkipDataset' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SkipDatasetInst {
    /// An instance of a fully built SkipDataset Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SkipDataset {
    /// Creates a new `SkipDataset`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `metadata` attribute.
    pub fn metadata<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.metadata = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SkipDataset` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input_dataset: O0,
        count: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input_dataset.into(), count.into(), scope)
    }
    fn build_impl(
        &self,
        input_dataset: crate::Output,
        count: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SkipDataset", |nd| {
            nd.add_input(input_dataset);
            nd.add_input(count);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.metadata {
                nd.set_attr_string("metadata", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SkipDataset' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_dataset: crate::Output,
        count: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SkipDatasetInst> {
        let op = scope.new_operation("SkipDataset", |builder| {
            builder.add_input(input_dataset);
            builder.add_input(count);
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.metadata {
                builder.set_attr_string("metadata", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SkipDatasetInst { op })
    }
}
impl SkipDatasetInst {
    /// Returns the 'handle' Output of this 'SkipDataset' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_dataset' Input of this 'SkipDataset' operation.
    pub fn input_dataset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'count' Input of this 'SkipDataset' operation.
    pub fn count(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<SkipDatasetInst> for crate::Operation {
    fn from(inst: SkipDatasetInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SkipDataset::new().build(input_dataset, count, scope)`.
pub fn skip_dataset<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    input_dataset: O0,
    count: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SkipDataset::new().build(input_dataset, count, scope)
}

/// Builder for the `Skipgram` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Skipgram {
    filename: ::std::option::Option<::std::string::String>,
    batch_size: ::std::option::Option<i64>,
    window_size: ::std::option::Option<i64>,
    min_count: ::std::option::Option<i64>,
    subsample: ::std::option::Option<f32>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Skipgram' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SkipgramInst {
    /// An instance of a fully built Skipgram Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Skipgram {
    /// Creates a new `Skipgram`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `filename` attribute.
    pub fn filename<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.filename = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `batch_size` attribute.
    pub fn batch_size<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.batch_size = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `window_size` attribute.
    pub fn window_size<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.window_size = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `min_count` attribute.
    pub fn min_count<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.min_count = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `subsample` attribute.
    pub fn subsample<ArgType: ::std::convert::Into<f32>>(mut self, value: ArgType) -> Self {
        self.subsample = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Skipgram` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("Skipgram", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.filename {
                nd.set_attr_string("filename", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.batch_size {
                nd.set_attr_int("batch_size", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.window_size {
                nd.set_attr_int("window_size", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.min_count {
                nd.set_attr_int("min_count", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.subsample {
                nd.set_attr_float("subsample", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Skipgram' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(&self, scope: &mut crate::Scope) -> crate::Result<SkipgramInst> {
        let op = scope.new_operation("Skipgram", |builder| {
            if let ::std::option::Option::Some(value) = &self.filename {
                builder.set_attr_string("filename", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.batch_size {
                builder.set_attr_int("batch_size", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.window_size {
                builder.set_attr_int("window_size", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.min_count {
                builder.set_attr_int("min_count", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.subsample {
                builder.set_attr_float("subsample", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SkipgramInst { op })
    }
}
impl SkipgramInst {
    /// Returns the 'vocab_word' Output of this 'Skipgram' operation.
    pub fn vocab_word(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'vocab_freq' Output of this 'Skipgram' operation.
    pub fn vocab_freq(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'words_per_epoch' Output of this 'Skipgram' operation.
    pub fn words_per_epoch(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns the 'current_epoch' Output of this 'Skipgram' operation.
    pub fn current_epoch(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 3,
        }
    }
    /// Returns the 'total_words_processed' Output of this 'Skipgram' operation.
    pub fn total_words_processed(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 4,
        }
    }
    /// Returns the 'examples' Output of this 'Skipgram' operation.
    pub fn examples(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 5,
        }
    }
    /// Returns the 'labels' Output of this 'Skipgram' operation.
    pub fn labels(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 6,
        }
    }
}
impl From<SkipgramInst> for crate::Operation {
    fn from(inst: SkipgramInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Skipgram::new().build(scope)`.
pub fn skipgram(scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
    Skipgram::new().build(scope)
}

/// Builder for the `SleepDataset` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SleepDataset {
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SleepDataset' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SleepDatasetInst {
    /// An instance of a fully built SleepDataset Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SleepDataset {
    /// Creates a new `SleepDataset`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SleepDataset` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input_dataset: O0,
        sleep_microseconds: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input_dataset.into(), sleep_microseconds.into(), scope)
    }
    fn build_impl(
        &self,
        input_dataset: crate::Output,
        sleep_microseconds: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SleepDataset", |nd| {
            nd.add_input(input_dataset);
            nd.add_input(sleep_microseconds);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SleepDataset' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_dataset: crate::Output,
        sleep_microseconds: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SleepDatasetInst> {
        let op = scope.new_operation("SleepDataset", |builder| {
            builder.add_input(input_dataset);
            builder.add_input(sleep_microseconds);
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SleepDatasetInst { op })
    }
}
impl SleepDatasetInst {
    /// Returns the 'handle' Output of this 'SleepDataset' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_dataset' Input of this 'SleepDataset' operation.
    pub fn input_dataset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'sleep_microseconds' Input of this 'SleepDataset' operation.
    pub fn sleep_microseconds(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<SleepDatasetInst> for crate::Operation {
    fn from(inst: SleepDatasetInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SleepDataset::new().build(input_dataset, sleep_microseconds, scope)`.
pub fn sleep_dataset<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    input_dataset: O0,
    sleep_microseconds: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SleepDataset::new().build(input_dataset, sleep_microseconds, scope)
}

/// Builder for the `Slice` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Slice {
    T: ::std::option::Option<crate::DataType>,
    Index: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Slice' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SliceInst {
    /// An instance of a fully built Slice Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Slice {
    /// Creates a new `Slice`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Index` attribute.
    pub fn Index<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Index = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Slice` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        begin: O1,
        size: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), begin.into(), size.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        begin: crate::Output,
        size: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Slice", |nd| {
            nd.add_input(input);
            nd.add_input(begin);
            nd.add_input(size);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Index {
                nd.set_attr_type("Index", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Slice' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        begin: crate::Output,
        size: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SliceInst> {
        let op = scope.new_operation("Slice", |builder| {
            builder.add_input(input);
            builder.add_input(begin);
            builder.add_input(size);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Index {
                builder.set_attr_type("Index", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SliceInst { op })
    }
}
impl SliceInst {
    /// Returns the 'output' Output of this 'Slice' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'Slice' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'begin' Input of this 'Slice' operation.
    pub fn begin(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'size' Input of this 'Slice' operation.
    pub fn size(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<SliceInst> for crate::Operation {
    fn from(inst: SliceInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Slice::new().build(input, begin, size, scope)`.
pub fn slice<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    input: O0,
    begin: O1,
    size: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Slice::new().build(input, begin, size, scope)
}

/// Builder for the `SlidingWindowDataset` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SlidingWindowDataset {
    drop_remainder: ::std::option::Option<bool>,
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SlidingWindowDataset' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SlidingWindowDatasetInst {
    /// An instance of a fully built SlidingWindowDataset Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SlidingWindowDataset {
    /// Creates a new `SlidingWindowDataset`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `drop_remainder` attribute.
    pub fn drop_remainder<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.drop_remainder = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SlidingWindowDataset` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input_dataset: O0,
        window_size: O1,
        window_shift: O2,
        window_stride: O3,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            input_dataset.into(),
            window_size.into(),
            window_shift.into(),
            window_stride.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        input_dataset: crate::Output,
        window_size: crate::Output,
        window_shift: crate::Output,
        window_stride: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SlidingWindowDataset", |nd| {
            nd.add_input(input_dataset);
            nd.add_input(window_size);
            nd.add_input(window_shift);
            nd.add_input(window_stride);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.drop_remainder {
                nd.set_attr_bool("drop_remainder", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SlidingWindowDataset' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_dataset: crate::Output,
        window_size: crate::Output,
        window_shift: crate::Output,
        window_stride: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SlidingWindowDatasetInst> {
        let op = scope.new_operation("SlidingWindowDataset", |builder| {
            builder.add_input(input_dataset);
            builder.add_input(window_size);
            builder.add_input(window_shift);
            builder.add_input(window_stride);
            if let ::std::option::Option::Some(value) = &self.drop_remainder {
                builder.set_attr_bool("drop_remainder", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SlidingWindowDatasetInst { op })
    }
}
impl SlidingWindowDatasetInst {
    /// Returns the 'handle' Output of this 'SlidingWindowDataset' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_dataset' Input of this 'SlidingWindowDataset' operation.
    pub fn input_dataset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'window_size' Input of this 'SlidingWindowDataset' operation.
    pub fn window_size(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'window_shift' Input of this 'SlidingWindowDataset' operation.
    pub fn window_shift(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'window_stride' Input of this 'SlidingWindowDataset' operation.
    pub fn window_stride(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
}
impl From<SlidingWindowDatasetInst> for crate::Operation {
    fn from(inst: SlidingWindowDatasetInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SlidingWindowDataset::new().build(input_dataset, window_size, window_shift, window_stride, scope)`.
pub fn sliding_window_dataset<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
>(
    input_dataset: O0,
    window_size: O1,
    window_shift: O2,
    window_stride: O3,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SlidingWindowDataset::new().build(
        input_dataset,
        window_size,
        window_shift,
        window_stride,
        scope,
    )
}

/// Builder for the `Snapshot` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Snapshot {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Snapshot' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SnapshotInst {
    /// An instance of a fully built Snapshot Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Snapshot {
    /// Creates a new `Snapshot`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Snapshot` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Snapshot", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Snapshot' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SnapshotInst> {
        let op = scope.new_operation("Snapshot", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SnapshotInst { op })
    }
}
impl SnapshotInst {
    /// Returns the 'output' Output of this 'Snapshot' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'Snapshot' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<SnapshotInst> for crate::Operation {
    fn from(inst: SnapshotInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Snapshot::new().build(input, scope)`.
pub fn snapshot<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Snapshot::new().build(input, scope)
}

/// Builder for the `SnapshotChunkDataset` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SnapshotChunkDataset {
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    compression: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SnapshotChunkDataset' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SnapshotChunkDatasetInst {
    /// An instance of a fully built SnapshotChunkDataset Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SnapshotChunkDataset {
    /// Creates a new `SnapshotChunkDataset`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `compression` attribute.
    pub fn compression<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.compression = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SnapshotChunkDataset` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        chunk_file: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(chunk_file.into(), scope)
    }
    fn build_impl(
        &self,
        chunk_file: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SnapshotChunkDataset", |nd| {
            nd.add_input(chunk_file);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.compression {
                nd.set_attr_string("compression", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SnapshotChunkDataset' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        chunk_file: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SnapshotChunkDatasetInst> {
        let op = scope.new_operation("SnapshotChunkDataset", |builder| {
            builder.add_input(chunk_file);
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.compression {
                builder.set_attr_string("compression", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SnapshotChunkDatasetInst { op })
    }
}
impl SnapshotChunkDatasetInst {
    /// Returns the 'handle' Output of this 'SnapshotChunkDataset' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'chunk_file' Input of this 'SnapshotChunkDataset' operation.
    pub fn chunk_file(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<SnapshotChunkDatasetInst> for crate::Operation {
    fn from(inst: SnapshotChunkDatasetInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SnapshotChunkDataset::new().build(chunk_file, scope)`.
pub fn snapshot_chunk_dataset<O0: ::std::convert::Into<crate::Output>>(
    chunk_file: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SnapshotChunkDataset::new().build(chunk_file, scope)
}

/// Builder for the `SnapshotDataset` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SnapshotDataset {
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    compression: ::std::option::Option<::std::string::String>,
    reader_path_prefix: ::std::option::Option<::std::string::String>,
    writer_path_prefix: ::std::option::Option<::std::string::String>,
    shard_size_bytes: ::std::option::Option<i64>,
    pending_snapshot_expiry_seconds: ::std::option::Option<i64>,
    num_reader_threads: ::std::option::Option<i64>,
    reader_buffer_size: ::std::option::Option<i64>,
    num_writer_threads: ::std::option::Option<i64>,
    writer_buffer_size: ::std::option::Option<i64>,
    shuffle_on_read: ::std::option::Option<bool>,
    seed: ::std::option::Option<i64>,
    seed2: ::std::option::Option<i64>,
    mode: ::std::option::Option<::std::string::String>,
    snapshot_name: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SnapshotDataset' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SnapshotDatasetInst {
    /// An instance of a fully built SnapshotDataset Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SnapshotDataset {
    /// Creates a new `SnapshotDataset`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `compression` attribute.
    pub fn compression<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.compression = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `reader_path_prefix` attribute.
    pub fn reader_path_prefix<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.reader_path_prefix = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `writer_path_prefix` attribute.
    pub fn writer_path_prefix<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.writer_path_prefix = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shard_size_bytes` attribute.
    pub fn shard_size_bytes<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.shard_size_bytes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `pending_snapshot_expiry_seconds` attribute.
    pub fn pending_snapshot_expiry_seconds<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.pending_snapshot_expiry_seconds = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `num_reader_threads` attribute.
    pub fn num_reader_threads<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.num_reader_threads = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `reader_buffer_size` attribute.
    pub fn reader_buffer_size<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.reader_buffer_size = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `num_writer_threads` attribute.
    pub fn num_writer_threads<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.num_writer_threads = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `writer_buffer_size` attribute.
    pub fn writer_buffer_size<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.writer_buffer_size = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shuffle_on_read` attribute.
    pub fn shuffle_on_read<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.shuffle_on_read = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `seed` attribute.
    pub fn seed<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.seed = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `seed2` attribute.
    pub fn seed2<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.seed2 = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `mode` attribute.
    pub fn mode<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.mode = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `snapshot_name` attribute.
    pub fn snapshot_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.snapshot_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SnapshotDataset` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input_dataset: O0,
        path: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input_dataset.into(), path.into(), scope)
    }
    fn build_impl(
        &self,
        input_dataset: crate::Output,
        path: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SnapshotDataset", |nd| {
            nd.add_input(input_dataset);
            nd.add_input(path);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.compression {
                nd.set_attr_string("compression", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.reader_path_prefix {
                nd.set_attr_string("reader_path_prefix", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.writer_path_prefix {
                nd.set_attr_string("writer_path_prefix", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shard_size_bytes {
                nd.set_attr_int("shard_size_bytes", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.pending_snapshot_expiry_seconds {
                nd.set_attr_int("pending_snapshot_expiry_seconds", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_reader_threads {
                nd.set_attr_int("num_reader_threads", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.reader_buffer_size {
                nd.set_attr_int("reader_buffer_size", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_writer_threads {
                nd.set_attr_int("num_writer_threads", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.writer_buffer_size {
                nd.set_attr_int("writer_buffer_size", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shuffle_on_read {
                nd.set_attr_bool("shuffle_on_read", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed {
                nd.set_attr_int("seed", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed2 {
                nd.set_attr_int("seed2", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.mode {
                nd.set_attr_string("mode", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.snapshot_name {
                nd.set_attr_string("snapshot_name", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SnapshotDataset' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_dataset: crate::Output,
        path: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SnapshotDatasetInst> {
        let op = scope.new_operation("SnapshotDataset", |builder| {
            builder.add_input(input_dataset);
            builder.add_input(path);
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.compression {
                builder.set_attr_string("compression", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.reader_path_prefix {
                builder.set_attr_string("reader_path_prefix", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.writer_path_prefix {
                builder.set_attr_string("writer_path_prefix", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shard_size_bytes {
                builder.set_attr_int("shard_size_bytes", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.pending_snapshot_expiry_seconds {
                builder.set_attr_int("pending_snapshot_expiry_seconds", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_reader_threads {
                builder.set_attr_int("num_reader_threads", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.reader_buffer_size {
                builder.set_attr_int("reader_buffer_size", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_writer_threads {
                builder.set_attr_int("num_writer_threads", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.writer_buffer_size {
                builder.set_attr_int("writer_buffer_size", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shuffle_on_read {
                builder.set_attr_bool("shuffle_on_read", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed {
                builder.set_attr_int("seed", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed2 {
                builder.set_attr_int("seed2", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.mode {
                builder.set_attr_string("mode", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.snapshot_name {
                builder.set_attr_string("snapshot_name", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SnapshotDatasetInst { op })
    }
}
impl SnapshotDatasetInst {
    /// Returns the 'handle' Output of this 'SnapshotDataset' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_dataset' Input of this 'SnapshotDataset' operation.
    pub fn input_dataset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'path' Input of this 'SnapshotDataset' operation.
    pub fn path(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<SnapshotDatasetInst> for crate::Operation {
    fn from(inst: SnapshotDatasetInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SnapshotDataset::new().build(input_dataset, path, scope)`.
pub fn snapshot_dataset<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    input_dataset: O0,
    path: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SnapshotDataset::new().build(input_dataset, path, scope)
}

/// Builder for the `SnapshotDatasetReader` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SnapshotDatasetReader {
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    compression: ::std::option::Option<::std::string::String>,
    version: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SnapshotDatasetReader' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SnapshotDatasetReaderInst {
    /// An instance of a fully built SnapshotDatasetReader Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SnapshotDatasetReader {
    /// Creates a new `SnapshotDatasetReader`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `compression` attribute.
    pub fn compression<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.compression = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `version` attribute.
    pub fn version<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.version = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SnapshotDatasetReader` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        shard_dir: O0,
        start_index: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(shard_dir.into(), start_index.into(), scope)
    }
    fn build_impl(
        &self,
        shard_dir: crate::Output,
        start_index: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SnapshotDatasetReader", |nd| {
            nd.add_input(shard_dir);
            nd.add_input(start_index);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.compression {
                nd.set_attr_string("compression", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.version {
                nd.set_attr_int("version", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SnapshotDatasetReader' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        shard_dir: crate::Output,
        start_index: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SnapshotDatasetReaderInst> {
        let op = scope.new_operation("SnapshotDatasetReader", |builder| {
            builder.add_input(shard_dir);
            builder.add_input(start_index);
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.compression {
                builder.set_attr_string("compression", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.version {
                builder.set_attr_int("version", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SnapshotDatasetReaderInst { op })
    }
}
impl SnapshotDatasetReaderInst {
    /// Returns the 'handle' Output of this 'SnapshotDatasetReader' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'shard_dir' Input of this 'SnapshotDatasetReader' operation.
    pub fn shard_dir(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'start_index' Input of this 'SnapshotDatasetReader' operation.
    pub fn start_index(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<SnapshotDatasetReaderInst> for crate::Operation {
    fn from(inst: SnapshotDatasetReaderInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SnapshotDatasetReader::new().build(shard_dir, start_index, scope)`.
pub fn snapshot_dataset_reader<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    shard_dir: O0,
    start_index: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SnapshotDatasetReader::new().build(shard_dir, start_index, scope)
}

/// Builder for the `SnapshotDatasetV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SnapshotDatasetV2 {
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    compression: ::std::option::Option<::std::string::String>,
    reader_prefix: ::std::option::Option<::std::string::String>,
    writer_prefix: ::std::option::Option<::std::string::String>,
    hash_valid: ::std::option::Option<bool>,
    hash: ::std::option::Option<i64>,
    reader_func: ::std::option::Option<::std::string::String>,
    shard_func: ::std::option::Option<::std::string::String>,
    Treader_func_args: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    Tshard_func_args: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    metadata: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SnapshotDatasetV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SnapshotDatasetV2Inst {
    /// An instance of a fully built SnapshotDatasetV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SnapshotDatasetV2 {
    /// Creates a new `SnapshotDatasetV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `compression` attribute.
    pub fn compression<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.compression = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `reader_prefix` attribute.
    pub fn reader_prefix<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.reader_prefix = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `writer_prefix` attribute.
    pub fn writer_prefix<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.writer_prefix = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `hash_valid` attribute.
    pub fn hash_valid<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.hash_valid = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `hash` attribute.
    pub fn hash<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.hash = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `reader_func` attribute.
    pub fn reader_func<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.reader_func = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shard_func` attribute.
    pub fn shard_func<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.shard_func = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Treader_func_args` attribute.
    pub fn Treader_func_args<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Treader_func_args = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tshard_func_args` attribute.
    pub fn Tshard_func_args<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tshard_func_args = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `metadata` attribute.
    pub fn metadata<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.metadata = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SnapshotDatasetV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input_dataset: O0,
        path: O1,
        reader_func_other_args: O2,
        shard_func_other_args: O3,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            input_dataset.into(),
            path.into(),
            reader_func_other_args.into(),
            shard_func_other_args.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        input_dataset: crate::Output,
        path: crate::Output,
        reader_func_other_args: crate::Output,
        shard_func_other_args: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SnapshotDatasetV2", |nd| {
            nd.add_input(input_dataset);
            nd.add_input(path);
            nd.add_input(reader_func_other_args);
            nd.add_input(shard_func_other_args);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.compression {
                nd.set_attr_string("compression", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.reader_prefix {
                nd.set_attr_string("reader_prefix", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.writer_prefix {
                nd.set_attr_string("writer_prefix", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.hash_valid {
                nd.set_attr_bool("hash_valid", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.hash {
                nd.set_attr_int("hash", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.reader_func {
                nd.set_attr_string("reader_func", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shard_func {
                nd.set_attr_string("shard_func", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Treader_func_args {
                nd.set_attr_type_list("Treader_func_args", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tshard_func_args {
                nd.set_attr_type_list("Tshard_func_args", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.metadata {
                nd.set_attr_string("metadata", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SnapshotDatasetV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_dataset: crate::Output,
        path: crate::Output,
        reader_func_other_args: crate::Output,
        shard_func_other_args: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SnapshotDatasetV2Inst> {
        let op = scope.new_operation("SnapshotDatasetV2", |builder| {
            builder.add_input(input_dataset);
            builder.add_input(path);
            builder.add_input(reader_func_other_args);
            builder.add_input(shard_func_other_args);
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.compression {
                builder.set_attr_string("compression", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.reader_prefix {
                builder.set_attr_string("reader_prefix", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.writer_prefix {
                builder.set_attr_string("writer_prefix", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.hash_valid {
                builder.set_attr_bool("hash_valid", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.hash {
                builder.set_attr_int("hash", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.reader_func {
                builder.set_attr_string("reader_func", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shard_func {
                builder.set_attr_string("shard_func", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Treader_func_args {
                builder.set_attr_type_list("Treader_func_args", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tshard_func_args {
                builder.set_attr_type_list("Tshard_func_args", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.metadata {
                builder.set_attr_string("metadata", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SnapshotDatasetV2Inst { op })
    }
}
impl SnapshotDatasetV2Inst {
    /// Returns the 'handle' Output of this 'SnapshotDatasetV2' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_dataset' Input of this 'SnapshotDatasetV2' operation.
    pub fn input_dataset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'path' Input of this 'SnapshotDatasetV2' operation.
    pub fn path(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'reader_func_other_args' Input of this 'SnapshotDatasetV2' operation.
    pub fn reader_func_other_args(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'shard_func_other_args' Input of this 'SnapshotDatasetV2' operation.
    pub fn shard_func_other_args(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
}
impl From<SnapshotDatasetV2Inst> for crate::Operation {
    fn from(inst: SnapshotDatasetV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SnapshotDatasetV2::new().build(input_dataset, path, reader_func_other_args, shard_func_other_args, scope)`.
pub fn snapshot_dataset_v2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
>(
    input_dataset: O0,
    path: O1,
    reader_func_other_args: O2,
    shard_func_other_args: O3,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SnapshotDatasetV2::new().build(
        input_dataset,
        path,
        reader_func_other_args,
        shard_func_other_args,
        scope,
    )
}

/// Builder for the `SnapshotNestedDatasetReader` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SnapshotNestedDatasetReader {
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    N: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SnapshotNestedDatasetReader' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SnapshotNestedDatasetReaderInst {
    /// An instance of a fully built SnapshotNestedDatasetReader Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SnapshotNestedDatasetReader {
    /// Creates a new `SnapshotNestedDatasetReader`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `N` attribute.
    pub fn N<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.N = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SnapshotNestedDatasetReader` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        inputs: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(inputs.into(), scope)
    }
    fn build_impl(
        &self,
        inputs: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SnapshotNestedDatasetReader", |nd| {
            nd.add_input(inputs);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.N {
                nd.set_attr_int("N", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SnapshotNestedDatasetReader' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        inputs: Vec<crate::Output>,
        scope: &mut crate::Scope,
    ) -> crate::Result<SnapshotNestedDatasetReaderInst> {
        let op = scope.new_operation("SnapshotNestedDatasetReader", |builder| {
            builder.add_input_list(&inputs);
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            builder.set_attr_int("N", inputs.clone().len() as i64)?;
            ::std::result::Result::Ok(())
        })?;
        Ok(SnapshotNestedDatasetReaderInst { op })
    }
}
impl SnapshotNestedDatasetReaderInst {
    /// Returns the 'handle' Output of this 'SnapshotNestedDatasetReader' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns a Vector of inputs for 'inputs' Input of this SnapshotNestedDatasetReader operation.
    pub fn inputs(&self) -> crate::Result<Vec<crate::Input>> {
        let mut Inputs = vec![];
        for i in 0..self.op.get_attr_int("N")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
}
impl From<SnapshotNestedDatasetReaderInst> for crate::Operation {
    fn from(inst: SnapshotNestedDatasetReaderInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SnapshotNestedDatasetReader::new().build(inputs, scope)`.
pub fn snapshot_nested_dataset_reader<O0: ::std::convert::Into<crate::Output>>(
    inputs: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SnapshotNestedDatasetReader::new().build(inputs, scope)
}

/// Builder for the `SobolSample` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SobolSample {
    dtype: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SobolSample' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SobolSampleInst {
    /// An instance of a fully built SobolSample Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SobolSample {
    /// Creates a new `SobolSample`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `dtype` attribute.
    pub fn dtype<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SobolSample` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        dim: O0,
        num_results: O1,
        skip: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(dim.into(), num_results.into(), skip.into(), scope)
    }
    fn build_impl(
        &self,
        dim: crate::Output,
        num_results: crate::Output,
        skip: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SobolSample", |nd| {
            nd.add_input(dim);
            nd.add_input(num_results);
            nd.add_input(skip);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                nd.set_attr_type("dtype", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SobolSample' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        dim: crate::Output,
        num_results: crate::Output,
        skip: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SobolSampleInst> {
        let op = scope.new_operation("SobolSample", |builder| {
            builder.add_input(dim);
            builder.add_input(num_results);
            builder.add_input(skip);
            if let ::std::option::Option::Some(value) = &self.dtype {
                builder.set_attr_type("dtype", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SobolSampleInst { op })
    }
}
impl SobolSampleInst {
    /// Returns the 'samples' Output of this 'SobolSample' operation.
    pub fn samples(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'dim' Input of this 'SobolSample' operation.
    pub fn dim(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'num_results' Input of this 'SobolSample' operation.
    pub fn num_results(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'skip' Input of this 'SobolSample' operation.
    pub fn skip(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<SobolSampleInst> for crate::Operation {
    fn from(inst: SobolSampleInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SobolSample::new().build(dim, num_results, skip, scope)`.
pub fn sobol_sample<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    dim: O0,
    num_results: O1,
    skip: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SobolSample::new().build(dim, num_results, skip, scope)
}

/// Builder for the `Softmax` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Softmax {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Softmax' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SoftmaxInst {
    /// An instance of a fully built Softmax Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Softmax {
    /// Creates a new `Softmax`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Softmax` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        logits: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(logits.into(), scope)
    }
    fn build_impl(
        &self,
        logits: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Softmax", |nd| {
            nd.add_input(logits);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Softmax' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        logits: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SoftmaxInst> {
        let op = scope.new_operation("Softmax", |builder| {
            builder.add_input(logits);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SoftmaxInst { op })
    }
}
impl SoftmaxInst {
    /// Returns the 'softmax' Output of this 'Softmax' operation.
    pub fn softmax(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'logits' Input of this 'Softmax' operation.
    pub fn logits(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<SoftmaxInst> for crate::Operation {
    fn from(inst: SoftmaxInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Softmax::new().build(logits, scope)`.
pub fn softmax<O0: ::std::convert::Into<crate::Output>>(
    logits: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Softmax::new().build(logits, scope)
}

/// Builder for the `SoftmaxCrossEntropyWithLogits` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SoftmaxCrossEntropyWithLogits {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SoftmaxCrossEntropyWithLogits' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SoftmaxCrossEntropyWithLogitsInst {
    /// An instance of a fully built SoftmaxCrossEntropyWithLogits Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SoftmaxCrossEntropyWithLogits {
    /// Creates a new `SoftmaxCrossEntropyWithLogits`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SoftmaxCrossEntropyWithLogits` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        features: O0,
        labels: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(features.into(), labels.into(), scope)
    }
    fn build_impl(
        &self,
        features: crate::Output,
        labels: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SoftmaxCrossEntropyWithLogits", |nd| {
            nd.add_input(features);
            nd.add_input(labels);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SoftmaxCrossEntropyWithLogits' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        features: crate::Output,
        labels: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SoftmaxCrossEntropyWithLogitsInst> {
        let op = scope.new_operation("SoftmaxCrossEntropyWithLogits", |builder| {
            builder.add_input(features);
            builder.add_input(labels);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SoftmaxCrossEntropyWithLogitsInst { op })
    }
}
impl SoftmaxCrossEntropyWithLogitsInst {
    /// Returns the 'loss' Output of this 'SoftmaxCrossEntropyWithLogits' operation.
    pub fn loss(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'backprop' Output of this 'SoftmaxCrossEntropyWithLogits' operation.
    pub fn backprop(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'features' Input of this 'SoftmaxCrossEntropyWithLogits' operation.
    pub fn features(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'labels' Input of this 'SoftmaxCrossEntropyWithLogits' operation.
    pub fn labels(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<SoftmaxCrossEntropyWithLogitsInst> for crate::Operation {
    fn from(inst: SoftmaxCrossEntropyWithLogitsInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SoftmaxCrossEntropyWithLogits::new().build(features, labels, scope)`.
pub fn softmax_cross_entropy_with_logits<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    features: O0,
    labels: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SoftmaxCrossEntropyWithLogits::new().build(features, labels, scope)
}

/// Builder for the `Softplus` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Softplus {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Softplus' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SoftplusInst {
    /// An instance of a fully built Softplus Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Softplus {
    /// Creates a new `Softplus`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Softplus` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        features: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(features.into(), scope)
    }
    fn build_impl(
        &self,
        features: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Softplus", |nd| {
            nd.add_input(features);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Softplus' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        features: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SoftplusInst> {
        let op = scope.new_operation("Softplus", |builder| {
            builder.add_input(features);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SoftplusInst { op })
    }
}
impl SoftplusInst {
    /// Returns the 'activations' Output of this 'Softplus' operation.
    pub fn activations(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'features' Input of this 'Softplus' operation.
    pub fn features(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<SoftplusInst> for crate::Operation {
    fn from(inst: SoftplusInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Softplus::new().build(features, scope)`.
pub fn softplus<O0: ::std::convert::Into<crate::Output>>(
    features: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Softplus::new().build(features, scope)
}

/// Builder for the `SoftplusGrad` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SoftplusGrad {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SoftplusGrad' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SoftplusGradInst {
    /// An instance of a fully built SoftplusGrad Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SoftplusGrad {
    /// Creates a new `SoftplusGrad`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SoftplusGrad` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        gradients: O0,
        features: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(gradients.into(), features.into(), scope)
    }
    fn build_impl(
        &self,
        gradients: crate::Output,
        features: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SoftplusGrad", |nd| {
            nd.add_input(gradients);
            nd.add_input(features);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SoftplusGrad' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        gradients: crate::Output,
        features: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SoftplusGradInst> {
        let op = scope.new_operation("SoftplusGrad", |builder| {
            builder.add_input(gradients);
            builder.add_input(features);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SoftplusGradInst { op })
    }
}
impl SoftplusGradInst {
    /// Returns the 'backprops' Output of this 'SoftplusGrad' operation.
    pub fn backprops(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'gradients' Input of this 'SoftplusGrad' operation.
    pub fn gradients(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'features' Input of this 'SoftplusGrad' operation.
    pub fn features(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<SoftplusGradInst> for crate::Operation {
    fn from(inst: SoftplusGradInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SoftplusGrad::new().build(gradients, features, scope)`.
pub fn softplus_grad<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    gradients: O0,
    features: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SoftplusGrad::new().build(gradients, features, scope)
}

/// Builder for the `Softsign` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Softsign {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Softsign' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SoftsignInst {
    /// An instance of a fully built Softsign Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Softsign {
    /// Creates a new `Softsign`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Softsign` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        features: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(features.into(), scope)
    }
    fn build_impl(
        &self,
        features: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Softsign", |nd| {
            nd.add_input(features);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Softsign' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        features: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SoftsignInst> {
        let op = scope.new_operation("Softsign", |builder| {
            builder.add_input(features);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SoftsignInst { op })
    }
}
impl SoftsignInst {
    /// Returns the 'activations' Output of this 'Softsign' operation.
    pub fn activations(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'features' Input of this 'Softsign' operation.
    pub fn features(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<SoftsignInst> for crate::Operation {
    fn from(inst: SoftsignInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Softsign::new().build(features, scope)`.
pub fn softsign<O0: ::std::convert::Into<crate::Output>>(
    features: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Softsign::new().build(features, scope)
}

/// Builder for the `SoftsignGrad` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SoftsignGrad {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SoftsignGrad' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SoftsignGradInst {
    /// An instance of a fully built SoftsignGrad Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SoftsignGrad {
    /// Creates a new `SoftsignGrad`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SoftsignGrad` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        gradients: O0,
        features: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(gradients.into(), features.into(), scope)
    }
    fn build_impl(
        &self,
        gradients: crate::Output,
        features: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SoftsignGrad", |nd| {
            nd.add_input(gradients);
            nd.add_input(features);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SoftsignGrad' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        gradients: crate::Output,
        features: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SoftsignGradInst> {
        let op = scope.new_operation("SoftsignGrad", |builder| {
            builder.add_input(gradients);
            builder.add_input(features);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SoftsignGradInst { op })
    }
}
impl SoftsignGradInst {
    /// Returns the 'backprops' Output of this 'SoftsignGrad' operation.
    pub fn backprops(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'gradients' Input of this 'SoftsignGrad' operation.
    pub fn gradients(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'features' Input of this 'SoftsignGrad' operation.
    pub fn features(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<SoftsignGradInst> for crate::Operation {
    fn from(inst: SoftsignGradInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SoftsignGrad::new().build(gradients, features, scope)`.
pub fn softsign_grad<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    gradients: O0,
    features: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SoftsignGrad::new().build(gradients, features, scope)
}

/// Builder for the `SpaceToBatch` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SpaceToBatch {
    T: ::std::option::Option<crate::DataType>,
    Tpaddings: ::std::option::Option<crate::DataType>,
    block_size: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SpaceToBatch' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SpaceToBatchInst {
    /// An instance of a fully built SpaceToBatch Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SpaceToBatch {
    /// Creates a new `SpaceToBatch`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tpaddings` attribute.
    pub fn Tpaddings<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tpaddings = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `block_size` attribute.
    pub fn block_size<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.block_size = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SpaceToBatch` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        paddings: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), paddings.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        paddings: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SpaceToBatch", |nd| {
            nd.add_input(input);
            nd.add_input(paddings);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tpaddings {
                nd.set_attr_type("Tpaddings", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.block_size {
                nd.set_attr_int("block_size", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SpaceToBatch' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        paddings: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SpaceToBatchInst> {
        let op = scope.new_operation("SpaceToBatch", |builder| {
            builder.add_input(input);
            builder.add_input(paddings);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tpaddings {
                builder.set_attr_type("Tpaddings", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.block_size {
                builder.set_attr_int("block_size", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SpaceToBatchInst { op })
    }
}
impl SpaceToBatchInst {
    /// Returns the 'output' Output of this 'SpaceToBatch' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'SpaceToBatch' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'paddings' Input of this 'SpaceToBatch' operation.
    pub fn paddings(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<SpaceToBatchInst> for crate::Operation {
    fn from(inst: SpaceToBatchInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SpaceToBatch::new().build(input, paddings, scope)`.
pub fn space_to_batch<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    input: O0,
    paddings: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SpaceToBatch::new().build(input, paddings, scope)
}

/// Builder for the `SpaceToBatchND` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SpaceToBatchND {
    T: ::std::option::Option<crate::DataType>,
    Tblock_shape: ::std::option::Option<crate::DataType>,
    Tpaddings: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SpaceToBatchND' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SpaceToBatchNDInst {
    /// An instance of a fully built SpaceToBatchND Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SpaceToBatchND {
    /// Creates a new `SpaceToBatchND`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tblock_shape` attribute.
    pub fn Tblock_shape<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tblock_shape = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tpaddings` attribute.
    pub fn Tpaddings<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tpaddings = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SpaceToBatchND` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        block_shape: O1,
        paddings: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), block_shape.into(), paddings.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        block_shape: crate::Output,
        paddings: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SpaceToBatchND", |nd| {
            nd.add_input(input);
            nd.add_input(block_shape);
            nd.add_input(paddings);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tblock_shape {
                nd.set_attr_type("Tblock_shape", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tpaddings {
                nd.set_attr_type("Tpaddings", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SpaceToBatchND' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        block_shape: crate::Output,
        paddings: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SpaceToBatchNDInst> {
        let op = scope.new_operation("SpaceToBatchND", |builder| {
            builder.add_input(input);
            builder.add_input(block_shape);
            builder.add_input(paddings);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tblock_shape {
                builder.set_attr_type("Tblock_shape", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tpaddings {
                builder.set_attr_type("Tpaddings", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SpaceToBatchNDInst { op })
    }
}
impl SpaceToBatchNDInst {
    /// Returns the 'output' Output of this 'SpaceToBatchND' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'SpaceToBatchND' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'block_shape' Input of this 'SpaceToBatchND' operation.
    pub fn block_shape(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'paddings' Input of this 'SpaceToBatchND' operation.
    pub fn paddings(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<SpaceToBatchNDInst> for crate::Operation {
    fn from(inst: SpaceToBatchNDInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SpaceToBatchND::new().build(input, block_shape, paddings, scope)`.
pub fn space_to_batch_nd<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    input: O0,
    block_shape: O1,
    paddings: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SpaceToBatchND::new().build(input, block_shape, paddings, scope)
}

/// Builder for the `SpaceToDepth` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SpaceToDepth {
    T: ::std::option::Option<crate::DataType>,
    block_size: ::std::option::Option<i64>,
    data_format: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SpaceToDepth' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SpaceToDepthInst {
    /// An instance of a fully built SpaceToDepth Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SpaceToDepth {
    /// Creates a new `SpaceToDepth`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `block_size` attribute.
    pub fn block_size<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.block_size = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `data_format` attribute.
    pub fn data_format<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.data_format = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SpaceToDepth` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SpaceToDepth", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.block_size {
                nd.set_attr_int("block_size", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.data_format {
                nd.set_attr_string("data_format", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SpaceToDepth' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SpaceToDepthInst> {
        let op = scope.new_operation("SpaceToDepth", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.block_size {
                builder.set_attr_int("block_size", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.data_format {
                builder.set_attr_string("data_format", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SpaceToDepthInst { op })
    }
}
impl SpaceToDepthInst {
    /// Returns the 'output' Output of this 'SpaceToDepth' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'SpaceToDepth' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<SpaceToDepthInst> for crate::Operation {
    fn from(inst: SpaceToDepthInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SpaceToDepth::new().build(input, scope)`.
pub fn space_to_depth<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SpaceToDepth::new().build(input, scope)
}

/// Builder for the `SparseAccumulatorApplyGradient` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SparseAccumulatorApplyGradient {
    dtype: ::std::option::Option<crate::DataType>,
    has_known_shape: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SparseAccumulatorApplyGradient' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SparseAccumulatorApplyGradientInst {
    /// An instance of a fully built SparseAccumulatorApplyGradient Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SparseAccumulatorApplyGradient {
    /// Creates a new `SparseAccumulatorApplyGradient`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `dtype` attribute.
    pub fn dtype<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `has_known_shape` attribute.
    pub fn has_known_shape<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.has_known_shape = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SparseAccumulatorApplyGradient` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
    >(
        &self,
        handle: O0,
        local_step: O1,
        gradient_indices: O2,
        gradient_values: O3,
        gradient_shape: O4,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            handle.into(),
            local_step.into(),
            gradient_indices.into(),
            gradient_values.into(),
            gradient_shape.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        handle: crate::Output,
        local_step: crate::Output,
        gradient_indices: crate::Output,
        gradient_values: crate::Output,
        gradient_shape: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SparseAccumulatorApplyGradient", |nd| {
            nd.add_input(handle);
            nd.add_input(local_step);
            nd.add_input(gradient_indices);
            nd.add_input(gradient_values);
            nd.add_input(gradient_shape);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                nd.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.has_known_shape {
                nd.set_attr_bool("has_known_shape", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SparseAccumulatorApplyGradient' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        handle: crate::Output,
        local_step: crate::Output,
        gradient_indices: crate::Output,
        gradient_values: crate::Output,
        gradient_shape: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SparseAccumulatorApplyGradientInst> {
        let op = scope.new_operation("SparseAccumulatorApplyGradient", |builder| {
            builder.add_input(handle);
            builder.add_input(local_step);
            builder.add_input(gradient_indices);
            builder.add_input(gradient_values);
            builder.add_input(gradient_shape);
            if let ::std::option::Option::Some(value) = &self.dtype {
                builder.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.has_known_shape {
                builder.set_attr_bool("has_known_shape", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SparseAccumulatorApplyGradientInst { op })
    }
}
impl SparseAccumulatorApplyGradientInst {
    /// Returns the 'handle' Input of this 'SparseAccumulatorApplyGradient' operation.
    pub fn handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'local_step' Input of this 'SparseAccumulatorApplyGradient' operation.
    pub fn local_step(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'gradient_indices' Input of this 'SparseAccumulatorApplyGradient' operation.
    pub fn gradient_indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'gradient_values' Input of this 'SparseAccumulatorApplyGradient' operation.
    pub fn gradient_values(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'gradient_shape' Input of this 'SparseAccumulatorApplyGradient' operation.
    pub fn gradient_shape(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
}
impl From<SparseAccumulatorApplyGradientInst> for crate::Operation {
    fn from(inst: SparseAccumulatorApplyGradientInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SparseAccumulatorApplyGradient::new().build(handle, local_step, gradient_indices, gradient_values, gradient_shape, scope)`.
pub fn sparse_accumulator_apply_gradient<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
>(
    handle: O0,
    local_step: O1,
    gradient_indices: O2,
    gradient_values: O3,
    gradient_shape: O4,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SparseAccumulatorApplyGradient::new().build(
        handle,
        local_step,
        gradient_indices,
        gradient_values,
        gradient_shape,
        scope,
    )
}

/// Builder for the `SparseAccumulatorTakeGradient` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SparseAccumulatorTakeGradient {
    dtype: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SparseAccumulatorTakeGradient' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SparseAccumulatorTakeGradientInst {
    /// An instance of a fully built SparseAccumulatorTakeGradient Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SparseAccumulatorTakeGradient {
    /// Creates a new `SparseAccumulatorTakeGradient`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `dtype` attribute.
    pub fn dtype<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SparseAccumulatorTakeGradient` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        handle: O0,
        num_required: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(handle.into(), num_required.into(), scope)
    }
    fn build_impl(
        &self,
        handle: crate::Output,
        num_required: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SparseAccumulatorTakeGradient", |nd| {
            nd.add_input(handle);
            nd.add_input(num_required);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                nd.set_attr_type("dtype", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SparseAccumulatorTakeGradient' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        handle: crate::Output,
        num_required: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SparseAccumulatorTakeGradientInst> {
        let op = scope.new_operation("SparseAccumulatorTakeGradient", |builder| {
            builder.add_input(handle);
            builder.add_input(num_required);
            if let ::std::option::Option::Some(value) = &self.dtype {
                builder.set_attr_type("dtype", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SparseAccumulatorTakeGradientInst { op })
    }
}
impl SparseAccumulatorTakeGradientInst {
    /// Returns the 'indices' Output of this 'SparseAccumulatorTakeGradient' operation.
    pub fn indices(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'values' Output of this 'SparseAccumulatorTakeGradient' operation.
    pub fn values(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'shape' Output of this 'SparseAccumulatorTakeGradient' operation.
    pub fn shape(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns the 'handle' Input of this 'SparseAccumulatorTakeGradient' operation.
    pub fn handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'num_required' Input of this 'SparseAccumulatorTakeGradient' operation.
    pub fn num_required(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<SparseAccumulatorTakeGradientInst> for crate::Operation {
    fn from(inst: SparseAccumulatorTakeGradientInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SparseAccumulatorTakeGradient::new().build(handle, num_required, scope)`.
pub fn sparse_accumulator_take_gradient<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    handle: O0,
    num_required: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SparseAccumulatorTakeGradient::new().build(handle, num_required, scope)
}

/// Builder for the `SparseAdd` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SparseAdd {
    T: ::std::option::Option<crate::DataType>,
    Treal: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SparseAdd' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SparseAddInst {
    /// An instance of a fully built SparseAdd Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SparseAdd {
    /// Creates a new `SparseAdd`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Treal` attribute.
    pub fn Treal<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Treal = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SparseAdd` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
        O6: ::std::convert::Into<crate::Output>,
    >(
        &self,
        a_indices: O0,
        a_values: O1,
        a_shape: O2,
        b_indices: O3,
        b_values: O4,
        b_shape: O5,
        thresh: O6,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            a_indices.into(),
            a_values.into(),
            a_shape.into(),
            b_indices.into(),
            b_values.into(),
            b_shape.into(),
            thresh.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        a_indices: crate::Output,
        a_values: crate::Output,
        a_shape: crate::Output,
        b_indices: crate::Output,
        b_values: crate::Output,
        b_shape: crate::Output,
        thresh: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SparseAdd", |nd| {
            nd.add_input(a_indices);
            nd.add_input(a_values);
            nd.add_input(a_shape);
            nd.add_input(b_indices);
            nd.add_input(b_values);
            nd.add_input(b_shape);
            nd.add_input(thresh);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Treal {
                nd.set_attr_type("Treal", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SparseAdd' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        a_indices: crate::Output,
        a_values: crate::Output,
        a_shape: crate::Output,
        b_indices: crate::Output,
        b_values: crate::Output,
        b_shape: crate::Output,
        thresh: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SparseAddInst> {
        let op = scope.new_operation("SparseAdd", |builder| {
            builder.add_input(a_indices);
            builder.add_input(a_values);
            builder.add_input(a_shape);
            builder.add_input(b_indices);
            builder.add_input(b_values);
            builder.add_input(b_shape);
            builder.add_input(thresh);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Treal {
                builder.set_attr_type("Treal", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SparseAddInst { op })
    }
}
impl SparseAddInst {
    /// Returns the 'sum_indices' Output of this 'SparseAdd' operation.
    pub fn sum_indices(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'sum_values' Output of this 'SparseAdd' operation.
    pub fn sum_values(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'sum_shape' Output of this 'SparseAdd' operation.
    pub fn sum_shape(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns the 'a_indices' Input of this 'SparseAdd' operation.
    pub fn a_indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'a_values' Input of this 'SparseAdd' operation.
    pub fn a_values(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'a_shape' Input of this 'SparseAdd' operation.
    pub fn a_shape(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'b_indices' Input of this 'SparseAdd' operation.
    pub fn b_indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'b_values' Input of this 'SparseAdd' operation.
    pub fn b_values(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
    /// Returns the 'b_shape' Input of this 'SparseAdd' operation.
    pub fn b_shape(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 5,
        }
    }
    /// Returns the 'thresh' Input of this 'SparseAdd' operation.
    pub fn thresh(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 6,
        }
    }
}
impl From<SparseAddInst> for crate::Operation {
    fn from(inst: SparseAddInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SparseAdd::new().build(a_indices, a_values, a_shape, b_indices, b_values, b_shape, thresh, scope)`.
pub fn sparse_add<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
    O6: ::std::convert::Into<crate::Output>,
>(
    a_indices: O0,
    a_values: O1,
    a_shape: O2,
    b_indices: O3,
    b_values: O4,
    b_shape: O5,
    thresh: O6,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SparseAdd::new().build(
        a_indices, a_values, a_shape, b_indices, b_values, b_shape, thresh, scope,
    )
}

/// Builder for the `SparseAddGrad` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SparseAddGrad {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SparseAddGrad' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SparseAddGradInst {
    /// An instance of a fully built SparseAddGrad Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SparseAddGrad {
    /// Creates a new `SparseAddGrad`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SparseAddGrad` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
    >(
        &self,
        backprop_val_grad: O0,
        a_indices: O1,
        b_indices: O2,
        sum_indices: O3,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            backprop_val_grad.into(),
            a_indices.into(),
            b_indices.into(),
            sum_indices.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        backprop_val_grad: crate::Output,
        a_indices: crate::Output,
        b_indices: crate::Output,
        sum_indices: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SparseAddGrad", |nd| {
            nd.add_input(backprop_val_grad);
            nd.add_input(a_indices);
            nd.add_input(b_indices);
            nd.add_input(sum_indices);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SparseAddGrad' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        backprop_val_grad: crate::Output,
        a_indices: crate::Output,
        b_indices: crate::Output,
        sum_indices: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SparseAddGradInst> {
        let op = scope.new_operation("SparseAddGrad", |builder| {
            builder.add_input(backprop_val_grad);
            builder.add_input(a_indices);
            builder.add_input(b_indices);
            builder.add_input(sum_indices);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SparseAddGradInst { op })
    }
}
impl SparseAddGradInst {
    /// Returns the 'a_val_grad' Output of this 'SparseAddGrad' operation.
    pub fn a_val_grad(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'b_val_grad' Output of this 'SparseAddGrad' operation.
    pub fn b_val_grad(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'backprop_val_grad' Input of this 'SparseAddGrad' operation.
    pub fn backprop_val_grad(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'a_indices' Input of this 'SparseAddGrad' operation.
    pub fn a_indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'b_indices' Input of this 'SparseAddGrad' operation.
    pub fn b_indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'sum_indices' Input of this 'SparseAddGrad' operation.
    pub fn sum_indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
}
impl From<SparseAddGradInst> for crate::Operation {
    fn from(inst: SparseAddGradInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SparseAddGrad::new().build(backprop_val_grad, a_indices, b_indices, sum_indices, scope)`.
pub fn sparse_add_grad<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
>(
    backprop_val_grad: O0,
    a_indices: O1,
    b_indices: O2,
    sum_indices: O3,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SparseAddGrad::new().build(backprop_val_grad, a_indices, b_indices, sum_indices, scope)
}

/// Builder for the `SparseApplyAdadelta` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SparseApplyAdadelta {
    T: ::std::option::Option<crate::DataType>,
    Tindices: ::std::option::Option<crate::DataType>,
    use_locking: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SparseApplyAdadelta' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SparseApplyAdadeltaInst {
    /// An instance of a fully built SparseApplyAdadelta Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SparseApplyAdadelta {
    /// Creates a new `SparseApplyAdadelta`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tindices` attribute.
    pub fn Tindices<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tindices = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_locking` attribute.
    pub fn use_locking<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.use_locking = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SparseApplyAdadelta` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
        O6: ::std::convert::Into<crate::Output>,
        O7: ::std::convert::Into<crate::Output>,
    >(
        &self,
        var: O0,
        accum: O1,
        accum_update: O2,
        lr: O3,
        rho: O4,
        epsilon: O5,
        grad: O6,
        indices: O7,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            var.into(),
            accum.into(),
            accum_update.into(),
            lr.into(),
            rho.into(),
            epsilon.into(),
            grad.into(),
            indices.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        var: crate::Output,
        accum: crate::Output,
        accum_update: crate::Output,
        lr: crate::Output,
        rho: crate::Output,
        epsilon: crate::Output,
        grad: crate::Output,
        indices: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SparseApplyAdadelta", |nd| {
            nd.add_input(var);
            nd.add_input(accum);
            nd.add_input(accum_update);
            nd.add_input(lr);
            nd.add_input(rho);
            nd.add_input(epsilon);
            nd.add_input(grad);
            nd.add_input(indices);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                nd.set_attr_type("Tindices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                nd.set_attr_bool("use_locking", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SparseApplyAdadelta' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        var: crate::Output,
        accum: crate::Output,
        accum_update: crate::Output,
        lr: crate::Output,
        rho: crate::Output,
        epsilon: crate::Output,
        grad: crate::Output,
        indices: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SparseApplyAdadeltaInst> {
        let op = scope.new_operation("SparseApplyAdadelta", |builder| {
            builder.add_input(var);
            builder.add_input(accum);
            builder.add_input(accum_update);
            builder.add_input(lr);
            builder.add_input(rho);
            builder.add_input(epsilon);
            builder.add_input(grad);
            builder.add_input(indices);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                builder.set_attr_type("Tindices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                builder.set_attr_bool("use_locking", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SparseApplyAdadeltaInst { op })
    }
}
impl SparseApplyAdadeltaInst {
    /// Returns the 'out' Output of this 'SparseApplyAdadelta' operation.
    pub fn out(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'var' Input of this 'SparseApplyAdadelta' operation.
    pub fn var(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'accum' Input of this 'SparseApplyAdadelta' operation.
    pub fn accum(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'accum_update' Input of this 'SparseApplyAdadelta' operation.
    pub fn accum_update(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'lr' Input of this 'SparseApplyAdadelta' operation.
    pub fn lr(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'rho' Input of this 'SparseApplyAdadelta' operation.
    pub fn rho(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
    /// Returns the 'epsilon' Input of this 'SparseApplyAdadelta' operation.
    pub fn epsilon(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 5,
        }
    }
    /// Returns the 'grad' Input of this 'SparseApplyAdadelta' operation.
    pub fn grad(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 6,
        }
    }
    /// Returns the 'indices' Input of this 'SparseApplyAdadelta' operation.
    pub fn indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 7,
        }
    }
}
impl From<SparseApplyAdadeltaInst> for crate::Operation {
    fn from(inst: SparseApplyAdadeltaInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SparseApplyAdadelta::new().build(var, accum, accum_update, lr, rho, epsilon, grad, indices, scope)`.
pub fn sparse_apply_adadelta<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
    O6: ::std::convert::Into<crate::Output>,
    O7: ::std::convert::Into<crate::Output>,
>(
    var: O0,
    accum: O1,
    accum_update: O2,
    lr: O3,
    rho: O4,
    epsilon: O5,
    grad: O6,
    indices: O7,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SparseApplyAdadelta::new().build(
        var,
        accum,
        accum_update,
        lr,
        rho,
        epsilon,
        grad,
        indices,
        scope,
    )
}

/// Builder for the `SparseApplyAdagrad` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SparseApplyAdagrad {
    T: ::std::option::Option<crate::DataType>,
    Tindices: ::std::option::Option<crate::DataType>,
    use_locking: ::std::option::Option<bool>,
    update_slots: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SparseApplyAdagrad' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SparseApplyAdagradInst {
    /// An instance of a fully built SparseApplyAdagrad Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SparseApplyAdagrad {
    /// Creates a new `SparseApplyAdagrad`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tindices` attribute.
    pub fn Tindices<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tindices = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_locking` attribute.
    pub fn use_locking<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.use_locking = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `update_slots` attribute.
    pub fn update_slots<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.update_slots = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SparseApplyAdagrad` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
    >(
        &self,
        var: O0,
        accum: O1,
        lr: O2,
        grad: O3,
        indices: O4,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            var.into(),
            accum.into(),
            lr.into(),
            grad.into(),
            indices.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        var: crate::Output,
        accum: crate::Output,
        lr: crate::Output,
        grad: crate::Output,
        indices: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SparseApplyAdagrad", |nd| {
            nd.add_input(var);
            nd.add_input(accum);
            nd.add_input(lr);
            nd.add_input(grad);
            nd.add_input(indices);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                nd.set_attr_type("Tindices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                nd.set_attr_bool("use_locking", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.update_slots {
                nd.set_attr_bool("update_slots", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SparseApplyAdagrad' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        var: crate::Output,
        accum: crate::Output,
        lr: crate::Output,
        grad: crate::Output,
        indices: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SparseApplyAdagradInst> {
        let op = scope.new_operation("SparseApplyAdagrad", |builder| {
            builder.add_input(var);
            builder.add_input(accum);
            builder.add_input(lr);
            builder.add_input(grad);
            builder.add_input(indices);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                builder.set_attr_type("Tindices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                builder.set_attr_bool("use_locking", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.update_slots {
                builder.set_attr_bool("update_slots", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SparseApplyAdagradInst { op })
    }
}
impl SparseApplyAdagradInst {
    /// Returns the 'out' Output of this 'SparseApplyAdagrad' operation.
    pub fn out(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'var' Input of this 'SparseApplyAdagrad' operation.
    pub fn var(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'accum' Input of this 'SparseApplyAdagrad' operation.
    pub fn accum(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'lr' Input of this 'SparseApplyAdagrad' operation.
    pub fn lr(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'grad' Input of this 'SparseApplyAdagrad' operation.
    pub fn grad(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'indices' Input of this 'SparseApplyAdagrad' operation.
    pub fn indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
}
impl From<SparseApplyAdagradInst> for crate::Operation {
    fn from(inst: SparseApplyAdagradInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SparseApplyAdagrad::new().build(var, accum, lr, grad, indices, scope)`.
pub fn sparse_apply_adagrad<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
>(
    var: O0,
    accum: O1,
    lr: O2,
    grad: O3,
    indices: O4,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SparseApplyAdagrad::new().build(var, accum, lr, grad, indices, scope)
}

/// Builder for the `SparseApplyAdagradDA` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SparseApplyAdagradDA {
    T: ::std::option::Option<crate::DataType>,
    Tindices: ::std::option::Option<crate::DataType>,
    use_locking: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SparseApplyAdagradDA' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SparseApplyAdagradDAInst {
    /// An instance of a fully built SparseApplyAdagradDA Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SparseApplyAdagradDA {
    /// Creates a new `SparseApplyAdagradDA`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tindices` attribute.
    pub fn Tindices<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tindices = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_locking` attribute.
    pub fn use_locking<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.use_locking = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SparseApplyAdagradDA` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
        O6: ::std::convert::Into<crate::Output>,
        O7: ::std::convert::Into<crate::Output>,
        O8: ::std::convert::Into<crate::Output>,
    >(
        &self,
        var: O0,
        gradient_accumulator: O1,
        gradient_squared_accumulator: O2,
        grad: O3,
        indices: O4,
        lr: O5,
        l1: O6,
        l2: O7,
        global_step: O8,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            var.into(),
            gradient_accumulator.into(),
            gradient_squared_accumulator.into(),
            grad.into(),
            indices.into(),
            lr.into(),
            l1.into(),
            l2.into(),
            global_step.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        var: crate::Output,
        gradient_accumulator: crate::Output,
        gradient_squared_accumulator: crate::Output,
        grad: crate::Output,
        indices: crate::Output,
        lr: crate::Output,
        l1: crate::Output,
        l2: crate::Output,
        global_step: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SparseApplyAdagradDA", |nd| {
            nd.add_input(var);
            nd.add_input(gradient_accumulator);
            nd.add_input(gradient_squared_accumulator);
            nd.add_input(grad);
            nd.add_input(indices);
            nd.add_input(lr);
            nd.add_input(l1);
            nd.add_input(l2);
            nd.add_input(global_step);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                nd.set_attr_type("Tindices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                nd.set_attr_bool("use_locking", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SparseApplyAdagradDA' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        var: crate::Output,
        gradient_accumulator: crate::Output,
        gradient_squared_accumulator: crate::Output,
        grad: crate::Output,
        indices: crate::Output,
        lr: crate::Output,
        l1: crate::Output,
        l2: crate::Output,
        global_step: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SparseApplyAdagradDAInst> {
        let op = scope.new_operation("SparseApplyAdagradDA", |builder| {
            builder.add_input(var);
            builder.add_input(gradient_accumulator);
            builder.add_input(gradient_squared_accumulator);
            builder.add_input(grad);
            builder.add_input(indices);
            builder.add_input(lr);
            builder.add_input(l1);
            builder.add_input(l2);
            builder.add_input(global_step);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                builder.set_attr_type("Tindices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                builder.set_attr_bool("use_locking", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SparseApplyAdagradDAInst { op })
    }
}
impl SparseApplyAdagradDAInst {
    /// Returns the 'out' Output of this 'SparseApplyAdagradDA' operation.
    pub fn out(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'var' Input of this 'SparseApplyAdagradDA' operation.
    pub fn var(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'gradient_accumulator' Input of this 'SparseApplyAdagradDA' operation.
    pub fn gradient_accumulator(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'gradient_squared_accumulator' Input of this 'SparseApplyAdagradDA' operation.
    pub fn gradient_squared_accumulator(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'grad' Input of this 'SparseApplyAdagradDA' operation.
    pub fn grad(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'indices' Input of this 'SparseApplyAdagradDA' operation.
    pub fn indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
    /// Returns the 'lr' Input of this 'SparseApplyAdagradDA' operation.
    pub fn lr(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 5,
        }
    }
    /// Returns the 'l1' Input of this 'SparseApplyAdagradDA' operation.
    pub fn l1(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 6,
        }
    }
    /// Returns the 'l2' Input of this 'SparseApplyAdagradDA' operation.
    pub fn l2(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 7,
        }
    }
    /// Returns the 'global_step' Input of this 'SparseApplyAdagradDA' operation.
    pub fn global_step(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 8,
        }
    }
}
impl From<SparseApplyAdagradDAInst> for crate::Operation {
    fn from(inst: SparseApplyAdagradDAInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SparseApplyAdagradDA::new().build(var, gradient_accumulator, gradient_squared_accumulator, grad, indices, lr, l1, l2, global_step, scope)`.
pub fn sparse_apply_adagrad_da<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
    O6: ::std::convert::Into<crate::Output>,
    O7: ::std::convert::Into<crate::Output>,
    O8: ::std::convert::Into<crate::Output>,
>(
    var: O0,
    gradient_accumulator: O1,
    gradient_squared_accumulator: O2,
    grad: O3,
    indices: O4,
    lr: O5,
    l1: O6,
    l2: O7,
    global_step: O8,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SparseApplyAdagradDA::new().build(
        var,
        gradient_accumulator,
        gradient_squared_accumulator,
        grad,
        indices,
        lr,
        l1,
        l2,
        global_step,
        scope,
    )
}

/// Builder for the `SparseApplyAdagradV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SparseApplyAdagradV2 {
    T: ::std::option::Option<crate::DataType>,
    Tindices: ::std::option::Option<crate::DataType>,
    use_locking: ::std::option::Option<bool>,
    update_slots: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SparseApplyAdagradV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SparseApplyAdagradV2Inst {
    /// An instance of a fully built SparseApplyAdagradV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SparseApplyAdagradV2 {
    /// Creates a new `SparseApplyAdagradV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tindices` attribute.
    pub fn Tindices<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tindices = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_locking` attribute.
    pub fn use_locking<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.use_locking = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `update_slots` attribute.
    pub fn update_slots<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.update_slots = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SparseApplyAdagradV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
    >(
        &self,
        var: O0,
        accum: O1,
        lr: O2,
        epsilon: O3,
        grad: O4,
        indices: O5,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            var.into(),
            accum.into(),
            lr.into(),
            epsilon.into(),
            grad.into(),
            indices.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        var: crate::Output,
        accum: crate::Output,
        lr: crate::Output,
        epsilon: crate::Output,
        grad: crate::Output,
        indices: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SparseApplyAdagradV2", |nd| {
            nd.add_input(var);
            nd.add_input(accum);
            nd.add_input(lr);
            nd.add_input(epsilon);
            nd.add_input(grad);
            nd.add_input(indices);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                nd.set_attr_type("Tindices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                nd.set_attr_bool("use_locking", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.update_slots {
                nd.set_attr_bool("update_slots", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SparseApplyAdagradV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        var: crate::Output,
        accum: crate::Output,
        lr: crate::Output,
        epsilon: crate::Output,
        grad: crate::Output,
        indices: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SparseApplyAdagradV2Inst> {
        let op = scope.new_operation("SparseApplyAdagradV2", |builder| {
            builder.add_input(var);
            builder.add_input(accum);
            builder.add_input(lr);
            builder.add_input(epsilon);
            builder.add_input(grad);
            builder.add_input(indices);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                builder.set_attr_type("Tindices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                builder.set_attr_bool("use_locking", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.update_slots {
                builder.set_attr_bool("update_slots", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SparseApplyAdagradV2Inst { op })
    }
}
impl SparseApplyAdagradV2Inst {
    /// Returns the 'out' Output of this 'SparseApplyAdagradV2' operation.
    pub fn out(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'var' Input of this 'SparseApplyAdagradV2' operation.
    pub fn var(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'accum' Input of this 'SparseApplyAdagradV2' operation.
    pub fn accum(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'lr' Input of this 'SparseApplyAdagradV2' operation.
    pub fn lr(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'epsilon' Input of this 'SparseApplyAdagradV2' operation.
    pub fn epsilon(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'grad' Input of this 'SparseApplyAdagradV2' operation.
    pub fn grad(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
    /// Returns the 'indices' Input of this 'SparseApplyAdagradV2' operation.
    pub fn indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 5,
        }
    }
}
impl From<SparseApplyAdagradV2Inst> for crate::Operation {
    fn from(inst: SparseApplyAdagradV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SparseApplyAdagradV2::new().build(var, accum, lr, epsilon, grad, indices, scope)`.
pub fn sparse_apply_adagrad_v2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
>(
    var: O0,
    accum: O1,
    lr: O2,
    epsilon: O3,
    grad: O4,
    indices: O5,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SparseApplyAdagradV2::new().build(var, accum, lr, epsilon, grad, indices, scope)
}

/// Builder for the `SparseApplyCenteredRMSProp` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SparseApplyCenteredRMSProp {
    T: ::std::option::Option<crate::DataType>,
    Tindices: ::std::option::Option<crate::DataType>,
    use_locking: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SparseApplyCenteredRMSProp' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SparseApplyCenteredRMSPropInst {
    /// An instance of a fully built SparseApplyCenteredRMSProp Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SparseApplyCenteredRMSProp {
    /// Creates a new `SparseApplyCenteredRMSProp`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tindices` attribute.
    pub fn Tindices<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tindices = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_locking` attribute.
    pub fn use_locking<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.use_locking = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SparseApplyCenteredRMSProp` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
        O6: ::std::convert::Into<crate::Output>,
        O7: ::std::convert::Into<crate::Output>,
        O8: ::std::convert::Into<crate::Output>,
        O9: ::std::convert::Into<crate::Output>,
    >(
        &self,
        var: O0,
        mg: O1,
        ms: O2,
        mom: O3,
        lr: O4,
        rho: O5,
        momentum: O6,
        epsilon: O7,
        grad: O8,
        indices: O9,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            var.into(),
            mg.into(),
            ms.into(),
            mom.into(),
            lr.into(),
            rho.into(),
            momentum.into(),
            epsilon.into(),
            grad.into(),
            indices.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        var: crate::Output,
        mg: crate::Output,
        ms: crate::Output,
        mom: crate::Output,
        lr: crate::Output,
        rho: crate::Output,
        momentum: crate::Output,
        epsilon: crate::Output,
        grad: crate::Output,
        indices: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SparseApplyCenteredRMSProp", |nd| {
            nd.add_input(var);
            nd.add_input(mg);
            nd.add_input(ms);
            nd.add_input(mom);
            nd.add_input(lr);
            nd.add_input(rho);
            nd.add_input(momentum);
            nd.add_input(epsilon);
            nd.add_input(grad);
            nd.add_input(indices);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                nd.set_attr_type("Tindices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                nd.set_attr_bool("use_locking", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SparseApplyCenteredRMSProp' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        var: crate::Output,
        mg: crate::Output,
        ms: crate::Output,
        mom: crate::Output,
        lr: crate::Output,
        rho: crate::Output,
        momentum: crate::Output,
        epsilon: crate::Output,
        grad: crate::Output,
        indices: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SparseApplyCenteredRMSPropInst> {
        let op = scope.new_operation("SparseApplyCenteredRMSProp", |builder| {
            builder.add_input(var);
            builder.add_input(mg);
            builder.add_input(ms);
            builder.add_input(mom);
            builder.add_input(lr);
            builder.add_input(rho);
            builder.add_input(momentum);
            builder.add_input(epsilon);
            builder.add_input(grad);
            builder.add_input(indices);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                builder.set_attr_type("Tindices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                builder.set_attr_bool("use_locking", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SparseApplyCenteredRMSPropInst { op })
    }
}
impl SparseApplyCenteredRMSPropInst {
    /// Returns the 'out' Output of this 'SparseApplyCenteredRMSProp' operation.
    pub fn out(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'var' Input of this 'SparseApplyCenteredRMSProp' operation.
    pub fn var(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'mg' Input of this 'SparseApplyCenteredRMSProp' operation.
    pub fn mg(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'ms' Input of this 'SparseApplyCenteredRMSProp' operation.
    pub fn ms(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'mom' Input of this 'SparseApplyCenteredRMSProp' operation.
    pub fn mom(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'lr' Input of this 'SparseApplyCenteredRMSProp' operation.
    pub fn lr(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
    /// Returns the 'rho' Input of this 'SparseApplyCenteredRMSProp' operation.
    pub fn rho(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 5,
        }
    }
    /// Returns the 'momentum' Input of this 'SparseApplyCenteredRMSProp' operation.
    pub fn momentum(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 6,
        }
    }
    /// Returns the 'epsilon' Input of this 'SparseApplyCenteredRMSProp' operation.
    pub fn epsilon(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 7,
        }
    }
    /// Returns the 'grad' Input of this 'SparseApplyCenteredRMSProp' operation.
    pub fn grad(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 8,
        }
    }
    /// Returns the 'indices' Input of this 'SparseApplyCenteredRMSProp' operation.
    pub fn indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 9,
        }
    }
}
impl From<SparseApplyCenteredRMSPropInst> for crate::Operation {
    fn from(inst: SparseApplyCenteredRMSPropInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SparseApplyCenteredRMSProp::new().build(var, mg, ms, mom, lr, rho, momentum, epsilon, grad, indices, scope)`.
pub fn sparse_apply_centered_rmsprop<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
    O6: ::std::convert::Into<crate::Output>,
    O7: ::std::convert::Into<crate::Output>,
    O8: ::std::convert::Into<crate::Output>,
    O9: ::std::convert::Into<crate::Output>,
>(
    var: O0,
    mg: O1,
    ms: O2,
    mom: O3,
    lr: O4,
    rho: O5,
    momentum: O6,
    epsilon: O7,
    grad: O8,
    indices: O9,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SparseApplyCenteredRMSProp::new().build(
        var, mg, ms, mom, lr, rho, momentum, epsilon, grad, indices, scope,
    )
}

/// Builder for the `SparseApplyFtrl` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SparseApplyFtrl {
    T: ::std::option::Option<crate::DataType>,
    Tindices: ::std::option::Option<crate::DataType>,
    use_locking: ::std::option::Option<bool>,
    multiply_linear_by_lr: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SparseApplyFtrl' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SparseApplyFtrlInst {
    /// An instance of a fully built SparseApplyFtrl Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SparseApplyFtrl {
    /// Creates a new `SparseApplyFtrl`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tindices` attribute.
    pub fn Tindices<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tindices = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_locking` attribute.
    pub fn use_locking<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.use_locking = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `multiply_linear_by_lr` attribute.
    pub fn multiply_linear_by_lr<ArgType: ::std::convert::Into<bool>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.multiply_linear_by_lr = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SparseApplyFtrl` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
        O6: ::std::convert::Into<crate::Output>,
        O7: ::std::convert::Into<crate::Output>,
        O8: ::std::convert::Into<crate::Output>,
    >(
        &self,
        var: O0,
        accum: O1,
        linear: O2,
        grad: O3,
        indices: O4,
        lr: O5,
        l1: O6,
        l2: O7,
        lr_power: O8,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            var.into(),
            accum.into(),
            linear.into(),
            grad.into(),
            indices.into(),
            lr.into(),
            l1.into(),
            l2.into(),
            lr_power.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        var: crate::Output,
        accum: crate::Output,
        linear: crate::Output,
        grad: crate::Output,
        indices: crate::Output,
        lr: crate::Output,
        l1: crate::Output,
        l2: crate::Output,
        lr_power: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SparseApplyFtrl", |nd| {
            nd.add_input(var);
            nd.add_input(accum);
            nd.add_input(linear);
            nd.add_input(grad);
            nd.add_input(indices);
            nd.add_input(lr);
            nd.add_input(l1);
            nd.add_input(l2);
            nd.add_input(lr_power);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                nd.set_attr_type("Tindices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                nd.set_attr_bool("use_locking", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.multiply_linear_by_lr {
                nd.set_attr_bool("multiply_linear_by_lr", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SparseApplyFtrl' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        var: crate::Output,
        accum: crate::Output,
        linear: crate::Output,
        grad: crate::Output,
        indices: crate::Output,
        lr: crate::Output,
        l1: crate::Output,
        l2: crate::Output,
        lr_power: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SparseApplyFtrlInst> {
        let op = scope.new_operation("SparseApplyFtrl", |builder| {
            builder.add_input(var);
            builder.add_input(accum);
            builder.add_input(linear);
            builder.add_input(grad);
            builder.add_input(indices);
            builder.add_input(lr);
            builder.add_input(l1);
            builder.add_input(l2);
            builder.add_input(lr_power);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                builder.set_attr_type("Tindices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                builder.set_attr_bool("use_locking", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.multiply_linear_by_lr {
                builder.set_attr_bool("multiply_linear_by_lr", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SparseApplyFtrlInst { op })
    }
}
impl SparseApplyFtrlInst {
    /// Returns the 'out' Output of this 'SparseApplyFtrl' operation.
    pub fn out(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'var' Input of this 'SparseApplyFtrl' operation.
    pub fn var(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'accum' Input of this 'SparseApplyFtrl' operation.
    pub fn accum(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'linear' Input of this 'SparseApplyFtrl' operation.
    pub fn linear(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'grad' Input of this 'SparseApplyFtrl' operation.
    pub fn grad(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'indices' Input of this 'SparseApplyFtrl' operation.
    pub fn indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
    /// Returns the 'lr' Input of this 'SparseApplyFtrl' operation.
    pub fn lr(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 5,
        }
    }
    /// Returns the 'l1' Input of this 'SparseApplyFtrl' operation.
    pub fn l1(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 6,
        }
    }
    /// Returns the 'l2' Input of this 'SparseApplyFtrl' operation.
    pub fn l2(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 7,
        }
    }
    /// Returns the 'lr_power' Input of this 'SparseApplyFtrl' operation.
    pub fn lr_power(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 8,
        }
    }
}
impl From<SparseApplyFtrlInst> for crate::Operation {
    fn from(inst: SparseApplyFtrlInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SparseApplyFtrl::new().build(var, accum, linear, grad, indices, lr, l1, l2, lr_power, scope)`.
pub fn sparse_apply_ftrl<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
    O6: ::std::convert::Into<crate::Output>,
    O7: ::std::convert::Into<crate::Output>,
    O8: ::std::convert::Into<crate::Output>,
>(
    var: O0,
    accum: O1,
    linear: O2,
    grad: O3,
    indices: O4,
    lr: O5,
    l1: O6,
    l2: O7,
    lr_power: O8,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SparseApplyFtrl::new().build(
        var, accum, linear, grad, indices, lr, l1, l2, lr_power, scope,
    )
}

/// Builder for the `SparseApplyFtrlV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SparseApplyFtrlV2 {
    T: ::std::option::Option<crate::DataType>,
    Tindices: ::std::option::Option<crate::DataType>,
    use_locking: ::std::option::Option<bool>,
    multiply_linear_by_lr: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SparseApplyFtrlV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SparseApplyFtrlV2Inst {
    /// An instance of a fully built SparseApplyFtrlV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SparseApplyFtrlV2 {
    /// Creates a new `SparseApplyFtrlV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tindices` attribute.
    pub fn Tindices<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tindices = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_locking` attribute.
    pub fn use_locking<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.use_locking = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `multiply_linear_by_lr` attribute.
    pub fn multiply_linear_by_lr<ArgType: ::std::convert::Into<bool>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.multiply_linear_by_lr = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SparseApplyFtrlV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
        O6: ::std::convert::Into<crate::Output>,
        O7: ::std::convert::Into<crate::Output>,
        O8: ::std::convert::Into<crate::Output>,
        O9: ::std::convert::Into<crate::Output>,
    >(
        &self,
        var: O0,
        accum: O1,
        linear: O2,
        grad: O3,
        indices: O4,
        lr: O5,
        l1: O6,
        l2: O7,
        l2_shrinkage: O8,
        lr_power: O9,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            var.into(),
            accum.into(),
            linear.into(),
            grad.into(),
            indices.into(),
            lr.into(),
            l1.into(),
            l2.into(),
            l2_shrinkage.into(),
            lr_power.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        var: crate::Output,
        accum: crate::Output,
        linear: crate::Output,
        grad: crate::Output,
        indices: crate::Output,
        lr: crate::Output,
        l1: crate::Output,
        l2: crate::Output,
        l2_shrinkage: crate::Output,
        lr_power: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SparseApplyFtrlV2", |nd| {
            nd.add_input(var);
            nd.add_input(accum);
            nd.add_input(linear);
            nd.add_input(grad);
            nd.add_input(indices);
            nd.add_input(lr);
            nd.add_input(l1);
            nd.add_input(l2);
            nd.add_input(l2_shrinkage);
            nd.add_input(lr_power);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                nd.set_attr_type("Tindices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                nd.set_attr_bool("use_locking", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.multiply_linear_by_lr {
                nd.set_attr_bool("multiply_linear_by_lr", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SparseApplyFtrlV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        var: crate::Output,
        accum: crate::Output,
        linear: crate::Output,
        grad: crate::Output,
        indices: crate::Output,
        lr: crate::Output,
        l1: crate::Output,
        l2: crate::Output,
        l2_shrinkage: crate::Output,
        lr_power: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SparseApplyFtrlV2Inst> {
        let op = scope.new_operation("SparseApplyFtrlV2", |builder| {
            builder.add_input(var);
            builder.add_input(accum);
            builder.add_input(linear);
            builder.add_input(grad);
            builder.add_input(indices);
            builder.add_input(lr);
            builder.add_input(l1);
            builder.add_input(l2);
            builder.add_input(l2_shrinkage);
            builder.add_input(lr_power);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                builder.set_attr_type("Tindices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                builder.set_attr_bool("use_locking", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.multiply_linear_by_lr {
                builder.set_attr_bool("multiply_linear_by_lr", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SparseApplyFtrlV2Inst { op })
    }
}
impl SparseApplyFtrlV2Inst {
    /// Returns the 'out' Output of this 'SparseApplyFtrlV2' operation.
    pub fn out(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'var' Input of this 'SparseApplyFtrlV2' operation.
    pub fn var(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'accum' Input of this 'SparseApplyFtrlV2' operation.
    pub fn accum(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'linear' Input of this 'SparseApplyFtrlV2' operation.
    pub fn linear(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'grad' Input of this 'SparseApplyFtrlV2' operation.
    pub fn grad(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'indices' Input of this 'SparseApplyFtrlV2' operation.
    pub fn indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
    /// Returns the 'lr' Input of this 'SparseApplyFtrlV2' operation.
    pub fn lr(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 5,
        }
    }
    /// Returns the 'l1' Input of this 'SparseApplyFtrlV2' operation.
    pub fn l1(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 6,
        }
    }
    /// Returns the 'l2' Input of this 'SparseApplyFtrlV2' operation.
    pub fn l2(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 7,
        }
    }
    /// Returns the 'l2_shrinkage' Input of this 'SparseApplyFtrlV2' operation.
    pub fn l2_shrinkage(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 8,
        }
    }
    /// Returns the 'lr_power' Input of this 'SparseApplyFtrlV2' operation.
    pub fn lr_power(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 9,
        }
    }
}
impl From<SparseApplyFtrlV2Inst> for crate::Operation {
    fn from(inst: SparseApplyFtrlV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SparseApplyFtrlV2::new().build(var, accum, linear, grad, indices, lr, l1, l2, l2_shrinkage, lr_power, scope)`.
pub fn sparse_apply_ftrl_v2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
    O6: ::std::convert::Into<crate::Output>,
    O7: ::std::convert::Into<crate::Output>,
    O8: ::std::convert::Into<crate::Output>,
    O9: ::std::convert::Into<crate::Output>,
>(
    var: O0,
    accum: O1,
    linear: O2,
    grad: O3,
    indices: O4,
    lr: O5,
    l1: O6,
    l2: O7,
    l2_shrinkage: O8,
    lr_power: O9,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SparseApplyFtrlV2::new().build(
        var,
        accum,
        linear,
        grad,
        indices,
        lr,
        l1,
        l2,
        l2_shrinkage,
        lr_power,
        scope,
    )
}

/// Builder for the `SparseApplyMomentum` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SparseApplyMomentum {
    T: ::std::option::Option<crate::DataType>,
    Tindices: ::std::option::Option<crate::DataType>,
    use_locking: ::std::option::Option<bool>,
    use_nesterov: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SparseApplyMomentum' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SparseApplyMomentumInst {
    /// An instance of a fully built SparseApplyMomentum Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SparseApplyMomentum {
    /// Creates a new `SparseApplyMomentum`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tindices` attribute.
    pub fn Tindices<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tindices = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_locking` attribute.
    pub fn use_locking<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.use_locking = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_nesterov` attribute.
    pub fn use_nesterov<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.use_nesterov = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SparseApplyMomentum` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
    >(
        &self,
        var: O0,
        accum: O1,
        lr: O2,
        grad: O3,
        indices: O4,
        momentum: O5,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            var.into(),
            accum.into(),
            lr.into(),
            grad.into(),
            indices.into(),
            momentum.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        var: crate::Output,
        accum: crate::Output,
        lr: crate::Output,
        grad: crate::Output,
        indices: crate::Output,
        momentum: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SparseApplyMomentum", |nd| {
            nd.add_input(var);
            nd.add_input(accum);
            nd.add_input(lr);
            nd.add_input(grad);
            nd.add_input(indices);
            nd.add_input(momentum);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                nd.set_attr_type("Tindices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                nd.set_attr_bool("use_locking", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_nesterov {
                nd.set_attr_bool("use_nesterov", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SparseApplyMomentum' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        var: crate::Output,
        accum: crate::Output,
        lr: crate::Output,
        grad: crate::Output,
        indices: crate::Output,
        momentum: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SparseApplyMomentumInst> {
        let op = scope.new_operation("SparseApplyMomentum", |builder| {
            builder.add_input(var);
            builder.add_input(accum);
            builder.add_input(lr);
            builder.add_input(grad);
            builder.add_input(indices);
            builder.add_input(momentum);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                builder.set_attr_type("Tindices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                builder.set_attr_bool("use_locking", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_nesterov {
                builder.set_attr_bool("use_nesterov", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SparseApplyMomentumInst { op })
    }
}
impl SparseApplyMomentumInst {
    /// Returns the 'out' Output of this 'SparseApplyMomentum' operation.
    pub fn out(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'var' Input of this 'SparseApplyMomentum' operation.
    pub fn var(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'accum' Input of this 'SparseApplyMomentum' operation.
    pub fn accum(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'lr' Input of this 'SparseApplyMomentum' operation.
    pub fn lr(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'grad' Input of this 'SparseApplyMomentum' operation.
    pub fn grad(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'indices' Input of this 'SparseApplyMomentum' operation.
    pub fn indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
    /// Returns the 'momentum' Input of this 'SparseApplyMomentum' operation.
    pub fn momentum(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 5,
        }
    }
}
impl From<SparseApplyMomentumInst> for crate::Operation {
    fn from(inst: SparseApplyMomentumInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SparseApplyMomentum::new().build(var, accum, lr, grad, indices, momentum, scope)`.
pub fn sparse_apply_momentum<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
>(
    var: O0,
    accum: O1,
    lr: O2,
    grad: O3,
    indices: O4,
    momentum: O5,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SparseApplyMomentum::new().build(var, accum, lr, grad, indices, momentum, scope)
}

/// Builder for the `SparseApplyProximalAdagrad` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SparseApplyProximalAdagrad {
    T: ::std::option::Option<crate::DataType>,
    Tindices: ::std::option::Option<crate::DataType>,
    use_locking: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SparseApplyProximalAdagrad' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SparseApplyProximalAdagradInst {
    /// An instance of a fully built SparseApplyProximalAdagrad Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SparseApplyProximalAdagrad {
    /// Creates a new `SparseApplyProximalAdagrad`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tindices` attribute.
    pub fn Tindices<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tindices = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_locking` attribute.
    pub fn use_locking<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.use_locking = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SparseApplyProximalAdagrad` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
        O6: ::std::convert::Into<crate::Output>,
    >(
        &self,
        var: O0,
        accum: O1,
        lr: O2,
        l1: O3,
        l2: O4,
        grad: O5,
        indices: O6,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            var.into(),
            accum.into(),
            lr.into(),
            l1.into(),
            l2.into(),
            grad.into(),
            indices.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        var: crate::Output,
        accum: crate::Output,
        lr: crate::Output,
        l1: crate::Output,
        l2: crate::Output,
        grad: crate::Output,
        indices: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SparseApplyProximalAdagrad", |nd| {
            nd.add_input(var);
            nd.add_input(accum);
            nd.add_input(lr);
            nd.add_input(l1);
            nd.add_input(l2);
            nd.add_input(grad);
            nd.add_input(indices);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                nd.set_attr_type("Tindices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                nd.set_attr_bool("use_locking", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SparseApplyProximalAdagrad' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        var: crate::Output,
        accum: crate::Output,
        lr: crate::Output,
        l1: crate::Output,
        l2: crate::Output,
        grad: crate::Output,
        indices: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SparseApplyProximalAdagradInst> {
        let op = scope.new_operation("SparseApplyProximalAdagrad", |builder| {
            builder.add_input(var);
            builder.add_input(accum);
            builder.add_input(lr);
            builder.add_input(l1);
            builder.add_input(l2);
            builder.add_input(grad);
            builder.add_input(indices);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                builder.set_attr_type("Tindices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                builder.set_attr_bool("use_locking", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SparseApplyProximalAdagradInst { op })
    }
}
impl SparseApplyProximalAdagradInst {
    /// Returns the 'out' Output of this 'SparseApplyProximalAdagrad' operation.
    pub fn out(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'var' Input of this 'SparseApplyProximalAdagrad' operation.
    pub fn var(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'accum' Input of this 'SparseApplyProximalAdagrad' operation.
    pub fn accum(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'lr' Input of this 'SparseApplyProximalAdagrad' operation.
    pub fn lr(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'l1' Input of this 'SparseApplyProximalAdagrad' operation.
    pub fn l1(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'l2' Input of this 'SparseApplyProximalAdagrad' operation.
    pub fn l2(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
    /// Returns the 'grad' Input of this 'SparseApplyProximalAdagrad' operation.
    pub fn grad(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 5,
        }
    }
    /// Returns the 'indices' Input of this 'SparseApplyProximalAdagrad' operation.
    pub fn indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 6,
        }
    }
}
impl From<SparseApplyProximalAdagradInst> for crate::Operation {
    fn from(inst: SparseApplyProximalAdagradInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SparseApplyProximalAdagrad::new().build(var, accum, lr, l1, l2, grad, indices, scope)`.
pub fn sparse_apply_proximal_adagrad<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
    O6: ::std::convert::Into<crate::Output>,
>(
    var: O0,
    accum: O1,
    lr: O2,
    l1: O3,
    l2: O4,
    grad: O5,
    indices: O6,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SparseApplyProximalAdagrad::new().build(var, accum, lr, l1, l2, grad, indices, scope)
}

/// Builder for the `SparseApplyProximalGradientDescent` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SparseApplyProximalGradientDescent {
    T: ::std::option::Option<crate::DataType>,
    Tindices: ::std::option::Option<crate::DataType>,
    use_locking: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SparseApplyProximalGradientDescent' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SparseApplyProximalGradientDescentInst {
    /// An instance of a fully built SparseApplyProximalGradientDescent Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SparseApplyProximalGradientDescent {
    /// Creates a new `SparseApplyProximalGradientDescent`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tindices` attribute.
    pub fn Tindices<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tindices = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_locking` attribute.
    pub fn use_locking<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.use_locking = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SparseApplyProximalGradientDescent` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
    >(
        &self,
        var: O0,
        alpha: O1,
        l1: O2,
        l2: O3,
        grad: O4,
        indices: O5,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            var.into(),
            alpha.into(),
            l1.into(),
            l2.into(),
            grad.into(),
            indices.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        var: crate::Output,
        alpha: crate::Output,
        l1: crate::Output,
        l2: crate::Output,
        grad: crate::Output,
        indices: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SparseApplyProximalGradientDescent", |nd| {
            nd.add_input(var);
            nd.add_input(alpha);
            nd.add_input(l1);
            nd.add_input(l2);
            nd.add_input(grad);
            nd.add_input(indices);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                nd.set_attr_type("Tindices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                nd.set_attr_bool("use_locking", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SparseApplyProximalGradientDescent' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        var: crate::Output,
        alpha: crate::Output,
        l1: crate::Output,
        l2: crate::Output,
        grad: crate::Output,
        indices: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SparseApplyProximalGradientDescentInst> {
        let op = scope.new_operation("SparseApplyProximalGradientDescent", |builder| {
            builder.add_input(var);
            builder.add_input(alpha);
            builder.add_input(l1);
            builder.add_input(l2);
            builder.add_input(grad);
            builder.add_input(indices);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                builder.set_attr_type("Tindices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                builder.set_attr_bool("use_locking", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SparseApplyProximalGradientDescentInst { op })
    }
}
impl SparseApplyProximalGradientDescentInst {
    /// Returns the 'out' Output of this 'SparseApplyProximalGradientDescent' operation.
    pub fn out(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'var' Input of this 'SparseApplyProximalGradientDescent' operation.
    pub fn var(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'alpha' Input of this 'SparseApplyProximalGradientDescent' operation.
    pub fn alpha(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'l1' Input of this 'SparseApplyProximalGradientDescent' operation.
    pub fn l1(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'l2' Input of this 'SparseApplyProximalGradientDescent' operation.
    pub fn l2(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'grad' Input of this 'SparseApplyProximalGradientDescent' operation.
    pub fn grad(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
    /// Returns the 'indices' Input of this 'SparseApplyProximalGradientDescent' operation.
    pub fn indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 5,
        }
    }
}
impl From<SparseApplyProximalGradientDescentInst> for crate::Operation {
    fn from(inst: SparseApplyProximalGradientDescentInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SparseApplyProximalGradientDescent::new().build(var, alpha, l1, l2, grad, indices, scope)`.
pub fn sparse_apply_proximal_gradient_descent<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
>(
    var: O0,
    alpha: O1,
    l1: O2,
    l2: O3,
    grad: O4,
    indices: O5,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SparseApplyProximalGradientDescent::new().build(var, alpha, l1, l2, grad, indices, scope)
}

/// Builder for the `SparseApplyRMSProp` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SparseApplyRMSProp {
    T: ::std::option::Option<crate::DataType>,
    Tindices: ::std::option::Option<crate::DataType>,
    use_locking: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SparseApplyRMSProp' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SparseApplyRMSPropInst {
    /// An instance of a fully built SparseApplyRMSProp Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SparseApplyRMSProp {
    /// Creates a new `SparseApplyRMSProp`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tindices` attribute.
    pub fn Tindices<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tindices = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_locking` attribute.
    pub fn use_locking<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.use_locking = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SparseApplyRMSProp` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
        O6: ::std::convert::Into<crate::Output>,
        O7: ::std::convert::Into<crate::Output>,
        O8: ::std::convert::Into<crate::Output>,
    >(
        &self,
        var: O0,
        ms: O1,
        mom: O2,
        lr: O3,
        rho: O4,
        momentum: O5,
        epsilon: O6,
        grad: O7,
        indices: O8,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            var.into(),
            ms.into(),
            mom.into(),
            lr.into(),
            rho.into(),
            momentum.into(),
            epsilon.into(),
            grad.into(),
            indices.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        var: crate::Output,
        ms: crate::Output,
        mom: crate::Output,
        lr: crate::Output,
        rho: crate::Output,
        momentum: crate::Output,
        epsilon: crate::Output,
        grad: crate::Output,
        indices: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SparseApplyRMSProp", |nd| {
            nd.add_input(var);
            nd.add_input(ms);
            nd.add_input(mom);
            nd.add_input(lr);
            nd.add_input(rho);
            nd.add_input(momentum);
            nd.add_input(epsilon);
            nd.add_input(grad);
            nd.add_input(indices);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                nd.set_attr_type("Tindices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                nd.set_attr_bool("use_locking", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SparseApplyRMSProp' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        var: crate::Output,
        ms: crate::Output,
        mom: crate::Output,
        lr: crate::Output,
        rho: crate::Output,
        momentum: crate::Output,
        epsilon: crate::Output,
        grad: crate::Output,
        indices: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SparseApplyRMSPropInst> {
        let op = scope.new_operation("SparseApplyRMSProp", |builder| {
            builder.add_input(var);
            builder.add_input(ms);
            builder.add_input(mom);
            builder.add_input(lr);
            builder.add_input(rho);
            builder.add_input(momentum);
            builder.add_input(epsilon);
            builder.add_input(grad);
            builder.add_input(indices);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                builder.set_attr_type("Tindices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_locking {
                builder.set_attr_bool("use_locking", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SparseApplyRMSPropInst { op })
    }
}
impl SparseApplyRMSPropInst {
    /// Returns the 'out' Output of this 'SparseApplyRMSProp' operation.
    pub fn out(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'var' Input of this 'SparseApplyRMSProp' operation.
    pub fn var(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'ms' Input of this 'SparseApplyRMSProp' operation.
    pub fn ms(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'mom' Input of this 'SparseApplyRMSProp' operation.
    pub fn mom(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'lr' Input of this 'SparseApplyRMSProp' operation.
    pub fn lr(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'rho' Input of this 'SparseApplyRMSProp' operation.
    pub fn rho(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
    /// Returns the 'momentum' Input of this 'SparseApplyRMSProp' operation.
    pub fn momentum(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 5,
        }
    }
    /// Returns the 'epsilon' Input of this 'SparseApplyRMSProp' operation.
    pub fn epsilon(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 6,
        }
    }
    /// Returns the 'grad' Input of this 'SparseApplyRMSProp' operation.
    pub fn grad(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 7,
        }
    }
    /// Returns the 'indices' Input of this 'SparseApplyRMSProp' operation.
    pub fn indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 8,
        }
    }
}
impl From<SparseApplyRMSPropInst> for crate::Operation {
    fn from(inst: SparseApplyRMSPropInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SparseApplyRMSProp::new().build(var, ms, mom, lr, rho, momentum, epsilon, grad, indices, scope)`.
pub fn sparse_apply_rmsprop<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
    O6: ::std::convert::Into<crate::Output>,
    O7: ::std::convert::Into<crate::Output>,
    O8: ::std::convert::Into<crate::Output>,
>(
    var: O0,
    ms: O1,
    mom: O2,
    lr: O3,
    rho: O4,
    momentum: O5,
    epsilon: O6,
    grad: O7,
    indices: O8,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SparseApplyRMSProp::new().build(
        var, ms, mom, lr, rho, momentum, epsilon, grad, indices, scope,
    )
}

/// Builder for the `SparseBincount` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SparseBincount {
    Tidx: ::std::option::Option<crate::DataType>,
    T: ::std::option::Option<crate::DataType>,
    binary_output: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SparseBincount' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SparseBincountInst {
    /// An instance of a fully built SparseBincount Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SparseBincount {
    /// Creates a new `SparseBincount`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `Tidx` attribute.
    pub fn Tidx<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Tidx = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `binary_output` attribute.
    pub fn binary_output<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.binary_output = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SparseBincount` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
    >(
        &self,
        indices: O0,
        values: O1,
        dense_shape: O2,
        size: O3,
        weights: O4,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            indices.into(),
            values.into(),
            dense_shape.into(),
            size.into(),
            weights.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        indices: crate::Output,
        values: crate::Output,
        dense_shape: crate::Output,
        size: crate::Output,
        weights: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SparseBincount", |nd| {
            nd.add_input(indices);
            nd.add_input(values);
            nd.add_input(dense_shape);
            nd.add_input(size);
            nd.add_input(weights);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.Tidx {
                nd.set_attr_type("Tidx", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.binary_output {
                nd.set_attr_bool("binary_output", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SparseBincount' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        indices: crate::Output,
        values: crate::Output,
        dense_shape: crate::Output,
        size: crate::Output,
        weights: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SparseBincountInst> {
        let op = scope.new_operation("SparseBincount", |builder| {
            builder.add_input(indices);
            builder.add_input(values);
            builder.add_input(dense_shape);
            builder.add_input(size);
            builder.add_input(weights);
            if let ::std::option::Option::Some(value) = &self.Tidx {
                builder.set_attr_type("Tidx", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.binary_output {
                builder.set_attr_bool("binary_output", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SparseBincountInst { op })
    }
}
impl SparseBincountInst {
    /// Returns the 'output' Output of this 'SparseBincount' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'indices' Input of this 'SparseBincount' operation.
    pub fn indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'values' Input of this 'SparseBincount' operation.
    pub fn values(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'dense_shape' Input of this 'SparseBincount' operation.
    pub fn dense_shape(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'size' Input of this 'SparseBincount' operation.
    pub fn size(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'weights' Input of this 'SparseBincount' operation.
    pub fn weights(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
}
impl From<SparseBincountInst> for crate::Operation {
    fn from(inst: SparseBincountInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SparseBincount::new().build(indices, values, dense_shape, size, weights, scope)`.
pub fn sparse_bincount<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
>(
    indices: O0,
    values: O1,
    dense_shape: O2,
    size: O3,
    weights: O4,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SparseBincount::new().build(indices, values, dense_shape, size, weights, scope)
}

/// Builder for the `SparseConcat` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SparseConcat {
    concat_dim: ::std::option::Option<i64>,
    N: ::std::option::Option<i64>,
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SparseConcat' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SparseConcatInst {
    /// An instance of a fully built SparseConcat Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SparseConcat {
    /// Creates a new `SparseConcat`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `concat_dim` attribute.
    pub fn concat_dim<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.concat_dim = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `N` attribute.
    pub fn N<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.N = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SparseConcat` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        indices: O0,
        values: O1,
        shapes: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(indices.into(), values.into(), shapes.into(), scope)
    }
    fn build_impl(
        &self,
        indices: crate::Output,
        values: crate::Output,
        shapes: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SparseConcat", |nd| {
            nd.add_input(indices);
            nd.add_input(values);
            nd.add_input(shapes);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.concat_dim {
                nd.set_attr_int("concat_dim", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.N {
                nd.set_attr_int("N", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SparseConcat' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        indices: Vec<crate::Output>,
        values: Vec<crate::Output>,
        shapes: Vec<crate::Output>,
        scope: &mut crate::Scope,
    ) -> crate::Result<SparseConcatInst> {
        let op = scope.new_operation("SparseConcat", |builder| {
            builder.add_input_list(&indices);
            builder.add_input_list(&values);
            builder.add_input_list(&shapes);
            if let ::std::option::Option::Some(value) = &self.concat_dim {
                builder.set_attr_int("concat_dim", *value)?;
            }
            builder.set_attr_int("N", indices.clone().len() as i64)?;
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SparseConcatInst { op })
    }
}
impl SparseConcatInst {
    /// Returns the 'output_indices' Output of this 'SparseConcat' operation.
    pub fn output_indices(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'output_values' Output of this 'SparseConcat' operation.
    pub fn output_values(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'output_shape' Output of this 'SparseConcat' operation.
    pub fn output_shape(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns a Vector of indices for 'indices' Input of this SparseConcat operation.
    pub fn indices(&self) -> crate::Result<Vec<crate::Input>> {
        let mut Inputs = vec![];
        for i in 0..self.op.get_attr_int("N")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
    /// Returns a Vector of values for 'values' Input of this SparseConcat operation.
    pub fn values(&self) -> crate::Result<Vec<crate::Input>> {
        let dynamic_offset = (self.op.get_attr_int("N")? + 1) as i32;
        let mut Inputs = vec![];
        for i in dynamic_offset..dynamic_offset + self.op.get_attr_int("N")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
    /// Returns a Vector of shapes for 'shapes' Input of this SparseConcat operation.
    pub fn shapes(&self) -> crate::Result<Vec<crate::Input>> {
        let dynamic_offset = (2 * self.op.get_attr_int("N")? + 2) as i32;
        let mut Inputs = vec![];
        for i in dynamic_offset..dynamic_offset + self.op.get_attr_int("N")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
}
impl From<SparseConcatInst> for crate::Operation {
    fn from(inst: SparseConcatInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SparseConcat::new().build(indices, values, shapes, scope)`.
pub fn sparse_concat<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    indices: O0,
    values: O1,
    shapes: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SparseConcat::new().build(indices, values, shapes, scope)
}

/// Builder for the `SparseConditionalAccumulator` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SparseConditionalAccumulator {
    dtype: ::std::option::Option<crate::DataType>,
    shape: ::std::option::Option<crate::Shape>,
    container: ::std::option::Option<::std::string::String>,
    shared_name: ::std::option::Option<::std::string::String>,
    reduction_type: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SparseConditionalAccumulator' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SparseConditionalAccumulatorInst {
    /// An instance of a fully built SparseConditionalAccumulator Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SparseConditionalAccumulator {
    /// Creates a new `SparseConditionalAccumulator`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `dtype` attribute.
    pub fn dtype<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shape` attribute.
    pub fn shape<ArgType: ::std::convert::Into<crate::Shape>>(mut self, value: ArgType) -> Self {
        self.shape = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `container` attribute.
    pub fn container<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.container = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shared_name` attribute.
    pub fn shared_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.shared_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `reduction_type` attribute.
    pub fn reduction_type<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.reduction_type = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SparseConditionalAccumulator` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("SparseConditionalAccumulator", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                nd.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shape {
                nd.set_attr_shape("shape", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.container {
                nd.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                nd.set_attr_string("shared_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.reduction_type {
                nd.set_attr_string("reduction_type", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SparseConditionalAccumulator' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        scope: &mut crate::Scope,
    ) -> crate::Result<SparseConditionalAccumulatorInst> {
        let op = scope.new_operation("SparseConditionalAccumulator", |builder| {
            if let ::std::option::Option::Some(value) = &self.dtype {
                builder.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shape {
                builder.set_attr_shape("shape", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.container {
                builder.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                builder.set_attr_string("shared_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.reduction_type {
                builder.set_attr_string("reduction_type", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SparseConditionalAccumulatorInst { op })
    }
}
impl SparseConditionalAccumulatorInst {
    /// Returns the 'handle' Output of this 'SparseConditionalAccumulator' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
}
impl From<SparseConditionalAccumulatorInst> for crate::Operation {
    fn from(inst: SparseConditionalAccumulatorInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SparseConditionalAccumulator::new().build(scope)`.
pub fn sparse_conditional_accumulator(scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
    SparseConditionalAccumulator::new().build(scope)
}

/// Builder for the `SparseCountSparseOutput` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SparseCountSparseOutput {
    T: ::std::option::Option<crate::DataType>,
    minlength: ::std::option::Option<i64>,
    maxlength: ::std::option::Option<i64>,
    binary_output: ::std::option::Option<bool>,
    output_type: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SparseCountSparseOutput' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SparseCountSparseOutputInst {
    /// An instance of a fully built SparseCountSparseOutput Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SparseCountSparseOutput {
    /// Creates a new `SparseCountSparseOutput`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `minlength` attribute.
    pub fn minlength<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.minlength = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `maxlength` attribute.
    pub fn maxlength<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.maxlength = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `binary_output` attribute.
    pub fn binary_output<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.binary_output = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_type` attribute.
    pub fn output_type<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_type = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SparseCountSparseOutput` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
    >(
        &self,
        indices: O0,
        values: O1,
        dense_shape: O2,
        weights: O3,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            indices.into(),
            values.into(),
            dense_shape.into(),
            weights.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        indices: crate::Output,
        values: crate::Output,
        dense_shape: crate::Output,
        weights: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SparseCountSparseOutput", |nd| {
            nd.add_input(indices);
            nd.add_input(values);
            nd.add_input(dense_shape);
            nd.add_input(weights);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.minlength {
                nd.set_attr_int("minlength", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.maxlength {
                nd.set_attr_int("maxlength", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.binary_output {
                nd.set_attr_bool("binary_output", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_type {
                nd.set_attr_type("output_type", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SparseCountSparseOutput' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        indices: crate::Output,
        values: crate::Output,
        dense_shape: crate::Output,
        weights: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SparseCountSparseOutputInst> {
        let op = scope.new_operation("SparseCountSparseOutput", |builder| {
            builder.add_input(indices);
            builder.add_input(values);
            builder.add_input(dense_shape);
            builder.add_input(weights);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.minlength {
                builder.set_attr_int("minlength", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.maxlength {
                builder.set_attr_int("maxlength", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.binary_output {
                builder.set_attr_bool("binary_output", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_type {
                builder.set_attr_type("output_type", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SparseCountSparseOutputInst { op })
    }
}
impl SparseCountSparseOutputInst {
    /// Returns the 'output_indices' Output of this 'SparseCountSparseOutput' operation.
    pub fn output_indices(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'output_values' Output of this 'SparseCountSparseOutput' operation.
    pub fn output_values(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'output_dense_shape' Output of this 'SparseCountSparseOutput' operation.
    pub fn output_dense_shape(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns the 'indices' Input of this 'SparseCountSparseOutput' operation.
    pub fn indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'values' Input of this 'SparseCountSparseOutput' operation.
    pub fn values(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'dense_shape' Input of this 'SparseCountSparseOutput' operation.
    pub fn dense_shape(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'weights' Input of this 'SparseCountSparseOutput' operation.
    pub fn weights(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
}
impl From<SparseCountSparseOutputInst> for crate::Operation {
    fn from(inst: SparseCountSparseOutputInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SparseCountSparseOutput::new().build(indices, values, dense_shape, weights, scope)`.
pub fn sparse_count_sparse_output<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
>(
    indices: O0,
    values: O1,
    dense_shape: O2,
    weights: O3,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SparseCountSparseOutput::new().build(indices, values, dense_shape, weights, scope)
}

/// Builder for the `SparseCross` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SparseCross {
    N: ::std::option::Option<i64>,
    hashed_output: ::std::option::Option<bool>,
    num_buckets: ::std::option::Option<i64>,
    hash_key: ::std::option::Option<i64>,
    sparse_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    dense_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    out_type: ::std::option::Option<crate::DataType>,
    internal_type: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SparseCross' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SparseCrossInst {
    /// An instance of a fully built SparseCross Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SparseCross {
    /// Creates a new `SparseCross`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `N` attribute.
    pub fn N<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.N = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `hashed_output` attribute.
    pub fn hashed_output<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.hashed_output = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `num_buckets` attribute.
    pub fn num_buckets<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.num_buckets = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `hash_key` attribute.
    pub fn hash_key<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.hash_key = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `sparse_types` attribute.
    pub fn sparse_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.sparse_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `dense_types` attribute.
    pub fn dense_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.dense_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `out_type` attribute.
    pub fn out_type<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.out_type = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `internal_type` attribute.
    pub fn internal_type<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.internal_type = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SparseCross` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
    >(
        &self,
        indices: O0,
        values: O1,
        shapes: O2,
        dense_inputs: O3,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            indices.into(),
            values.into(),
            shapes.into(),
            dense_inputs.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        indices: crate::Output,
        values: crate::Output,
        shapes: crate::Output,
        dense_inputs: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SparseCross", |nd| {
            nd.add_input(indices);
            nd.add_input(values);
            nd.add_input(shapes);
            nd.add_input(dense_inputs);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.N {
                nd.set_attr_int("N", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.hashed_output {
                nd.set_attr_bool("hashed_output", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_buckets {
                nd.set_attr_int("num_buckets", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.hash_key {
                nd.set_attr_int("hash_key", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.sparse_types {
                nd.set_attr_type_list("sparse_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dense_types {
                nd.set_attr_type_list("dense_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.out_type {
                nd.set_attr_type("out_type", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.internal_type {
                nd.set_attr_type("internal_type", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SparseCross' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        indices: Vec<crate::Output>,
        values: crate::Output,
        shapes: Vec<crate::Output>,
        dense_inputs: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SparseCrossInst> {
        let op = scope.new_operation("SparseCross", |builder| {
            builder.add_input_list(&indices);
            builder.add_input(values);
            builder.add_input_list(&shapes);
            builder.add_input(dense_inputs);
            builder.set_attr_int("N", indices.clone().len() as i64)?;
            if let ::std::option::Option::Some(value) = &self.hashed_output {
                builder.set_attr_bool("hashed_output", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_buckets {
                builder.set_attr_int("num_buckets", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.hash_key {
                builder.set_attr_int("hash_key", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.sparse_types {
                builder.set_attr_type_list("sparse_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dense_types {
                builder.set_attr_type_list("dense_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.out_type {
                builder.set_attr_type("out_type", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.internal_type {
                builder.set_attr_type("internal_type", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SparseCrossInst { op })
    }
}
impl SparseCrossInst {
    /// Returns the 'output_indices' Output of this 'SparseCross' operation.
    pub fn output_indices(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'output_values' Output of this 'SparseCross' operation.
    pub fn output_values(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'output_shape' Output of this 'SparseCross' operation.
    pub fn output_shape(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns a Vector of indices for 'indices' Input of this SparseCross operation.
    pub fn indices(&self) -> crate::Result<Vec<crate::Input>> {
        let mut Inputs = vec![];
        for i in 0..self.op.get_attr_int("N")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
    /// Returns the 'values' Input of this 'SparseCross' operation.
    pub fn values(&self) -> crate::Result<crate::Input> {
        let dynamic_offset = (self.op.get_attr_int("N")? + 1) as i32;
        Ok(crate::Input {
            operation: &self.op,
            index: dynamic_offset,
        })
    }
    /// Returns a Vector of shapes for 'shapes' Input of this SparseCross operation.
    pub fn shapes(&self) -> crate::Result<Vec<crate::Input>> {
        let dynamic_offset = (self.op.get_attr_int("N")? + 2) as i32;
        let mut Inputs = vec![];
        for i in dynamic_offset..dynamic_offset + self.op.get_attr_int("N")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
    /// Returns the 'dense_inputs' Input of this 'SparseCross' operation.
    pub fn dense_inputs(&self) -> crate::Result<crate::Input> {
        let dynamic_offset = (2 * self.op.get_attr_int("N")? + 3) as i32;
        Ok(crate::Input {
            operation: &self.op,
            index: dynamic_offset,
        })
    }
}
impl From<SparseCrossInst> for crate::Operation {
    fn from(inst: SparseCrossInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SparseCross::new().build(indices, values, shapes, dense_inputs, scope)`.
pub fn sparse_cross<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
>(
    indices: O0,
    values: O1,
    shapes: O2,
    dense_inputs: O3,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SparseCross::new().build(indices, values, shapes, dense_inputs, scope)
}

/// Builder for the `SparseCrossHashed` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SparseCrossHashed {
    N: ::std::option::Option<i64>,
    sparse_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    dense_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SparseCrossHashed' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SparseCrossHashedInst {
    /// An instance of a fully built SparseCrossHashed Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SparseCrossHashed {
    /// Creates a new `SparseCrossHashed`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `N` attribute.
    pub fn N<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.N = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `sparse_types` attribute.
    pub fn sparse_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.sparse_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `dense_types` attribute.
    pub fn dense_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.dense_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SparseCrossHashed` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
        O6: ::std::convert::Into<crate::Output>,
    >(
        &self,
        indices: O0,
        values: O1,
        shapes: O2,
        dense_inputs: O3,
        num_buckets: O4,
        strong_hash: O5,
        salt: O6,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            indices.into(),
            values.into(),
            shapes.into(),
            dense_inputs.into(),
            num_buckets.into(),
            strong_hash.into(),
            salt.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        indices: crate::Output,
        values: crate::Output,
        shapes: crate::Output,
        dense_inputs: crate::Output,
        num_buckets: crate::Output,
        strong_hash: crate::Output,
        salt: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SparseCrossHashed", |nd| {
            nd.add_input(indices);
            nd.add_input(values);
            nd.add_input(shapes);
            nd.add_input(dense_inputs);
            nd.add_input(num_buckets);
            nd.add_input(strong_hash);
            nd.add_input(salt);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.N {
                nd.set_attr_int("N", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.sparse_types {
                nd.set_attr_type_list("sparse_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dense_types {
                nd.set_attr_type_list("dense_types", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SparseCrossHashed' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        indices: Vec<crate::Output>,
        values: crate::Output,
        shapes: Vec<crate::Output>,
        dense_inputs: crate::Output,
        num_buckets: crate::Output,
        strong_hash: crate::Output,
        salt: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SparseCrossHashedInst> {
        let op = scope.new_operation("SparseCrossHashed", |builder| {
            builder.add_input_list(&indices);
            builder.add_input(values);
            builder.add_input_list(&shapes);
            builder.add_input(dense_inputs);
            builder.add_input(num_buckets);
            builder.add_input(strong_hash);
            builder.add_input(salt);
            builder.set_attr_int("N", indices.clone().len() as i64)?;
            if let ::std::option::Option::Some(value) = &self.sparse_types {
                builder.set_attr_type_list("sparse_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dense_types {
                builder.set_attr_type_list("dense_types", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SparseCrossHashedInst { op })
    }
}
impl SparseCrossHashedInst {
    /// Returns the 'output_indices' Output of this 'SparseCrossHashed' operation.
    pub fn output_indices(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'output_values' Output of this 'SparseCrossHashed' operation.
    pub fn output_values(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'output_shape' Output of this 'SparseCrossHashed' operation.
    pub fn output_shape(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns a Vector of indices for 'indices' Input of this SparseCrossHashed operation.
    pub fn indices(&self) -> crate::Result<Vec<crate::Input>> {
        let mut Inputs = vec![];
        for i in 0..self.op.get_attr_int("N")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
    /// Returns the 'values' Input of this 'SparseCrossHashed' operation.
    pub fn values(&self) -> crate::Result<crate::Input> {
        let dynamic_offset = (self.op.get_attr_int("N")? + 1) as i32;
        Ok(crate::Input {
            operation: &self.op,
            index: dynamic_offset,
        })
    }
    /// Returns a Vector of shapes for 'shapes' Input of this SparseCrossHashed operation.
    pub fn shapes(&self) -> crate::Result<Vec<crate::Input>> {
        let dynamic_offset = (self.op.get_attr_int("N")? + 2) as i32;
        let mut Inputs = vec![];
        for i in dynamic_offset..dynamic_offset + self.op.get_attr_int("N")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
    /// Returns the 'dense_inputs' Input of this 'SparseCrossHashed' operation.
    pub fn dense_inputs(&self) -> crate::Result<crate::Input> {
        let dynamic_offset = (2 * self.op.get_attr_int("N")? + 3) as i32;
        Ok(crate::Input {
            operation: &self.op,
            index: dynamic_offset,
        })
    }
    /// Returns the 'num_buckets' Input of this 'SparseCrossHashed' operation.
    pub fn num_buckets(&self) -> crate::Result<crate::Input> {
        let dynamic_offset = (2 * self.op.get_attr_int("N")? + 4) as i32;
        Ok(crate::Input {
            operation: &self.op,
            index: dynamic_offset,
        })
    }
    /// Returns the 'strong_hash' Input of this 'SparseCrossHashed' operation.
    pub fn strong_hash(&self) -> crate::Result<crate::Input> {
        let dynamic_offset = (2 * self.op.get_attr_int("N")? + 5) as i32;
        Ok(crate::Input {
            operation: &self.op,
            index: dynamic_offset,
        })
    }
    /// Returns the 'salt' Input of this 'SparseCrossHashed' operation.
    pub fn salt(&self) -> crate::Result<crate::Input> {
        let dynamic_offset = (2 * self.op.get_attr_int("N")? + 6) as i32;
        Ok(crate::Input {
            operation: &self.op,
            index: dynamic_offset,
        })
    }
}
impl From<SparseCrossHashedInst> for crate::Operation {
    fn from(inst: SparseCrossHashedInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SparseCrossHashed::new().build(indices, values, shapes, dense_inputs, num_buckets, strong_hash, salt, scope)`.
pub fn sparse_cross_hashed<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
    O6: ::std::convert::Into<crate::Output>,
>(
    indices: O0,
    values: O1,
    shapes: O2,
    dense_inputs: O3,
    num_buckets: O4,
    strong_hash: O5,
    salt: O6,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SparseCrossHashed::new().build(
        indices,
        values,
        shapes,
        dense_inputs,
        num_buckets,
        strong_hash,
        salt,
        scope,
    )
}

/// Builder for the `SparseCrossV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SparseCrossV2 {
    N: ::std::option::Option<i64>,
    sparse_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    dense_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SparseCrossV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SparseCrossV2Inst {
    /// An instance of a fully built SparseCrossV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SparseCrossV2 {
    /// Creates a new `SparseCrossV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `N` attribute.
    pub fn N<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.N = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `sparse_types` attribute.
    pub fn sparse_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.sparse_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `dense_types` attribute.
    pub fn dense_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.dense_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SparseCrossV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
    >(
        &self,
        indices: O0,
        values: O1,
        shapes: O2,
        dense_inputs: O3,
        sep: O4,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            indices.into(),
            values.into(),
            shapes.into(),
            dense_inputs.into(),
            sep.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        indices: crate::Output,
        values: crate::Output,
        shapes: crate::Output,
        dense_inputs: crate::Output,
        sep: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SparseCrossV2", |nd| {
            nd.add_input(indices);
            nd.add_input(values);
            nd.add_input(shapes);
            nd.add_input(dense_inputs);
            nd.add_input(sep);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.N {
                nd.set_attr_int("N", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.sparse_types {
                nd.set_attr_type_list("sparse_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dense_types {
                nd.set_attr_type_list("dense_types", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SparseCrossV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        indices: Vec<crate::Output>,
        values: crate::Output,
        shapes: Vec<crate::Output>,
        dense_inputs: crate::Output,
        sep: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SparseCrossV2Inst> {
        let op = scope.new_operation("SparseCrossV2", |builder| {
            builder.add_input_list(&indices);
            builder.add_input(values);
            builder.add_input_list(&shapes);
            builder.add_input(dense_inputs);
            builder.add_input(sep);
            builder.set_attr_int("N", indices.clone().len() as i64)?;
            if let ::std::option::Option::Some(value) = &self.sparse_types {
                builder.set_attr_type_list("sparse_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dense_types {
                builder.set_attr_type_list("dense_types", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SparseCrossV2Inst { op })
    }
}
impl SparseCrossV2Inst {
    /// Returns the 'output_indices' Output of this 'SparseCrossV2' operation.
    pub fn output_indices(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'output_values' Output of this 'SparseCrossV2' operation.
    pub fn output_values(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'output_shape' Output of this 'SparseCrossV2' operation.
    pub fn output_shape(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns a Vector of indices for 'indices' Input of this SparseCrossV2 operation.
    pub fn indices(&self) -> crate::Result<Vec<crate::Input>> {
        let mut Inputs = vec![];
        for i in 0..self.op.get_attr_int("N")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
    /// Returns the 'values' Input of this 'SparseCrossV2' operation.
    pub fn values(&self) -> crate::Result<crate::Input> {
        let dynamic_offset = (self.op.get_attr_int("N")? + 1) as i32;
        Ok(crate::Input {
            operation: &self.op,
            index: dynamic_offset,
        })
    }
    /// Returns a Vector of shapes for 'shapes' Input of this SparseCrossV2 operation.
    pub fn shapes(&self) -> crate::Result<Vec<crate::Input>> {
        let dynamic_offset = (self.op.get_attr_int("N")? + 2) as i32;
        let mut Inputs = vec![];
        for i in dynamic_offset..dynamic_offset + self.op.get_attr_int("N")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
    /// Returns the 'dense_inputs' Input of this 'SparseCrossV2' operation.
    pub fn dense_inputs(&self) -> crate::Result<crate::Input> {
        let dynamic_offset = (2 * self.op.get_attr_int("N")? + 3) as i32;
        Ok(crate::Input {
            operation: &self.op,
            index: dynamic_offset,
        })
    }
    /// Returns the 'sep' Input of this 'SparseCrossV2' operation.
    pub fn sep(&self) -> crate::Result<crate::Input> {
        let dynamic_offset = (2 * self.op.get_attr_int("N")? + 4) as i32;
        Ok(crate::Input {
            operation: &self.op,
            index: dynamic_offset,
        })
    }
}
impl From<SparseCrossV2Inst> for crate::Operation {
    fn from(inst: SparseCrossV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SparseCrossV2::new().build(indices, values, shapes, dense_inputs, sep, scope)`.
pub fn sparse_cross_v2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
>(
    indices: O0,
    values: O1,
    shapes: O2,
    dense_inputs: O3,
    sep: O4,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SparseCrossV2::new().build(indices, values, shapes, dense_inputs, sep, scope)
}

/// Builder for the `SparseDenseCwiseAdd` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SparseDenseCwiseAdd {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SparseDenseCwiseAdd' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SparseDenseCwiseAddInst {
    /// An instance of a fully built SparseDenseCwiseAdd Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SparseDenseCwiseAdd {
    /// Creates a new `SparseDenseCwiseAdd`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SparseDenseCwiseAdd` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
    >(
        &self,
        sp_indices: O0,
        sp_values: O1,
        sp_shape: O2,
        dense: O3,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            sp_indices.into(),
            sp_values.into(),
            sp_shape.into(),
            dense.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        sp_indices: crate::Output,
        sp_values: crate::Output,
        sp_shape: crate::Output,
        dense: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SparseDenseCwiseAdd", |nd| {
            nd.add_input(sp_indices);
            nd.add_input(sp_values);
            nd.add_input(sp_shape);
            nd.add_input(dense);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SparseDenseCwiseAdd' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        sp_indices: crate::Output,
        sp_values: crate::Output,
        sp_shape: crate::Output,
        dense: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SparseDenseCwiseAddInst> {
        let op = scope.new_operation("SparseDenseCwiseAdd", |builder| {
            builder.add_input(sp_indices);
            builder.add_input(sp_values);
            builder.add_input(sp_shape);
            builder.add_input(dense);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SparseDenseCwiseAddInst { op })
    }
}
impl SparseDenseCwiseAddInst {
    /// Returns the 'output' Output of this 'SparseDenseCwiseAdd' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'sp_indices' Input of this 'SparseDenseCwiseAdd' operation.
    pub fn sp_indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'sp_values' Input of this 'SparseDenseCwiseAdd' operation.
    pub fn sp_values(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'sp_shape' Input of this 'SparseDenseCwiseAdd' operation.
    pub fn sp_shape(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'dense' Input of this 'SparseDenseCwiseAdd' operation.
    pub fn dense(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
}
impl From<SparseDenseCwiseAddInst> for crate::Operation {
    fn from(inst: SparseDenseCwiseAddInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SparseDenseCwiseAdd::new().build(sp_indices, sp_values, sp_shape, dense, scope)`.
pub fn sparse_dense_cwise_add<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
>(
    sp_indices: O0,
    sp_values: O1,
    sp_shape: O2,
    dense: O3,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SparseDenseCwiseAdd::new().build(sp_indices, sp_values, sp_shape, dense, scope)
}

/// Builder for the `SparseDenseCwiseDiv` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SparseDenseCwiseDiv {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SparseDenseCwiseDiv' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SparseDenseCwiseDivInst {
    /// An instance of a fully built SparseDenseCwiseDiv Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SparseDenseCwiseDiv {
    /// Creates a new `SparseDenseCwiseDiv`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SparseDenseCwiseDiv` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
    >(
        &self,
        sp_indices: O0,
        sp_values: O1,
        sp_shape: O2,
        dense: O3,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            sp_indices.into(),
            sp_values.into(),
            sp_shape.into(),
            dense.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        sp_indices: crate::Output,
        sp_values: crate::Output,
        sp_shape: crate::Output,
        dense: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SparseDenseCwiseDiv", |nd| {
            nd.add_input(sp_indices);
            nd.add_input(sp_values);
            nd.add_input(sp_shape);
            nd.add_input(dense);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SparseDenseCwiseDiv' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        sp_indices: crate::Output,
        sp_values: crate::Output,
        sp_shape: crate::Output,
        dense: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SparseDenseCwiseDivInst> {
        let op = scope.new_operation("SparseDenseCwiseDiv", |builder| {
            builder.add_input(sp_indices);
            builder.add_input(sp_values);
            builder.add_input(sp_shape);
            builder.add_input(dense);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SparseDenseCwiseDivInst { op })
    }
}
impl SparseDenseCwiseDivInst {
    /// Returns the 'output' Output of this 'SparseDenseCwiseDiv' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'sp_indices' Input of this 'SparseDenseCwiseDiv' operation.
    pub fn sp_indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'sp_values' Input of this 'SparseDenseCwiseDiv' operation.
    pub fn sp_values(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'sp_shape' Input of this 'SparseDenseCwiseDiv' operation.
    pub fn sp_shape(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'dense' Input of this 'SparseDenseCwiseDiv' operation.
    pub fn dense(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
}
impl From<SparseDenseCwiseDivInst> for crate::Operation {
    fn from(inst: SparseDenseCwiseDivInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SparseDenseCwiseDiv::new().build(sp_indices, sp_values, sp_shape, dense, scope)`.
pub fn sparse_dense_cwise_div<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
>(
    sp_indices: O0,
    sp_values: O1,
    sp_shape: O2,
    dense: O3,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SparseDenseCwiseDiv::new().build(sp_indices, sp_values, sp_shape, dense, scope)
}

/// Builder for the `SparseDenseCwiseMul` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SparseDenseCwiseMul {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SparseDenseCwiseMul' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SparseDenseCwiseMulInst {
    /// An instance of a fully built SparseDenseCwiseMul Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SparseDenseCwiseMul {
    /// Creates a new `SparseDenseCwiseMul`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SparseDenseCwiseMul` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
    >(
        &self,
        sp_indices: O0,
        sp_values: O1,
        sp_shape: O2,
        dense: O3,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            sp_indices.into(),
            sp_values.into(),
            sp_shape.into(),
            dense.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        sp_indices: crate::Output,
        sp_values: crate::Output,
        sp_shape: crate::Output,
        dense: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SparseDenseCwiseMul", |nd| {
            nd.add_input(sp_indices);
            nd.add_input(sp_values);
            nd.add_input(sp_shape);
            nd.add_input(dense);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SparseDenseCwiseMul' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        sp_indices: crate::Output,
        sp_values: crate::Output,
        sp_shape: crate::Output,
        dense: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SparseDenseCwiseMulInst> {
        let op = scope.new_operation("SparseDenseCwiseMul", |builder| {
            builder.add_input(sp_indices);
            builder.add_input(sp_values);
            builder.add_input(sp_shape);
            builder.add_input(dense);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SparseDenseCwiseMulInst { op })
    }
}
impl SparseDenseCwiseMulInst {
    /// Returns the 'output' Output of this 'SparseDenseCwiseMul' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'sp_indices' Input of this 'SparseDenseCwiseMul' operation.
    pub fn sp_indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'sp_values' Input of this 'SparseDenseCwiseMul' operation.
    pub fn sp_values(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'sp_shape' Input of this 'SparseDenseCwiseMul' operation.
    pub fn sp_shape(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'dense' Input of this 'SparseDenseCwiseMul' operation.
    pub fn dense(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
}
impl From<SparseDenseCwiseMulInst> for crate::Operation {
    fn from(inst: SparseDenseCwiseMulInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SparseDenseCwiseMul::new().build(sp_indices, sp_values, sp_shape, dense, scope)`.
pub fn sparse_dense_cwise_mul<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
>(
    sp_indices: O0,
    sp_values: O1,
    sp_shape: O2,
    dense: O3,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SparseDenseCwiseMul::new().build(sp_indices, sp_values, sp_shape, dense, scope)
}

/// Builder for the `SparseFillEmptyRows` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SparseFillEmptyRows {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SparseFillEmptyRows' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SparseFillEmptyRowsInst {
    /// An instance of a fully built SparseFillEmptyRows Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SparseFillEmptyRows {
    /// Creates a new `SparseFillEmptyRows`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SparseFillEmptyRows` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
    >(
        &self,
        indices: O0,
        values: O1,
        dense_shape: O2,
        default_value: O3,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            indices.into(),
            values.into(),
            dense_shape.into(),
            default_value.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        indices: crate::Output,
        values: crate::Output,
        dense_shape: crate::Output,
        default_value: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SparseFillEmptyRows", |nd| {
            nd.add_input(indices);
            nd.add_input(values);
            nd.add_input(dense_shape);
            nd.add_input(default_value);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SparseFillEmptyRows' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        indices: crate::Output,
        values: crate::Output,
        dense_shape: crate::Output,
        default_value: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SparseFillEmptyRowsInst> {
        let op = scope.new_operation("SparseFillEmptyRows", |builder| {
            builder.add_input(indices);
            builder.add_input(values);
            builder.add_input(dense_shape);
            builder.add_input(default_value);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SparseFillEmptyRowsInst { op })
    }
}
impl SparseFillEmptyRowsInst {
    /// Returns the 'output_indices' Output of this 'SparseFillEmptyRows' operation.
    pub fn output_indices(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'output_values' Output of this 'SparseFillEmptyRows' operation.
    pub fn output_values(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'empty_row_indicator' Output of this 'SparseFillEmptyRows' operation.
    pub fn empty_row_indicator(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns the 'reverse_index_map' Output of this 'SparseFillEmptyRows' operation.
    pub fn reverse_index_map(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 3,
        }
    }
    /// Returns the 'indices' Input of this 'SparseFillEmptyRows' operation.
    pub fn indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'values' Input of this 'SparseFillEmptyRows' operation.
    pub fn values(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'dense_shape' Input of this 'SparseFillEmptyRows' operation.
    pub fn dense_shape(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'default_value' Input of this 'SparseFillEmptyRows' operation.
    pub fn default_value(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
}
impl From<SparseFillEmptyRowsInst> for crate::Operation {
    fn from(inst: SparseFillEmptyRowsInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SparseFillEmptyRows::new().build(indices, values, dense_shape, default_value, scope)`.
pub fn sparse_fill_empty_rows<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
>(
    indices: O0,
    values: O1,
    dense_shape: O2,
    default_value: O3,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SparseFillEmptyRows::new().build(indices, values, dense_shape, default_value, scope)
}

/// Builder for the `SparseFillEmptyRowsGrad` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SparseFillEmptyRowsGrad {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SparseFillEmptyRowsGrad' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SparseFillEmptyRowsGradInst {
    /// An instance of a fully built SparseFillEmptyRowsGrad Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SparseFillEmptyRowsGrad {
    /// Creates a new `SparseFillEmptyRowsGrad`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SparseFillEmptyRowsGrad` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        reverse_index_map: O0,
        grad_values: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(reverse_index_map.into(), grad_values.into(), scope)
    }
    fn build_impl(
        &self,
        reverse_index_map: crate::Output,
        grad_values: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SparseFillEmptyRowsGrad", |nd| {
            nd.add_input(reverse_index_map);
            nd.add_input(grad_values);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SparseFillEmptyRowsGrad' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        reverse_index_map: crate::Output,
        grad_values: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SparseFillEmptyRowsGradInst> {
        let op = scope.new_operation("SparseFillEmptyRowsGrad", |builder| {
            builder.add_input(reverse_index_map);
            builder.add_input(grad_values);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SparseFillEmptyRowsGradInst { op })
    }
}
impl SparseFillEmptyRowsGradInst {
    /// Returns the 'd_values' Output of this 'SparseFillEmptyRowsGrad' operation.
    pub fn d_values(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'd_default_value' Output of this 'SparseFillEmptyRowsGrad' operation.
    pub fn d_default_value(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'reverse_index_map' Input of this 'SparseFillEmptyRowsGrad' operation.
    pub fn reverse_index_map(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'grad_values' Input of this 'SparseFillEmptyRowsGrad' operation.
    pub fn grad_values(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<SparseFillEmptyRowsGradInst> for crate::Operation {
    fn from(inst: SparseFillEmptyRowsGradInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SparseFillEmptyRowsGrad::new().build(reverse_index_map, grad_values, scope)`.
pub fn sparse_fill_empty_rows_grad<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    reverse_index_map: O0,
    grad_values: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SparseFillEmptyRowsGrad::new().build(reverse_index_map, grad_values, scope)
}

/// Builder for the `SparseMatMul` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SparseMatMul {
    transpose_a: ::std::option::Option<bool>,
    transpose_b: ::std::option::Option<bool>,
    a_is_sparse: ::std::option::Option<bool>,
    b_is_sparse: ::std::option::Option<bool>,
    Ta: ::std::option::Option<crate::DataType>,
    Tb: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SparseMatMul' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SparseMatMulInst {
    /// An instance of a fully built SparseMatMul Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SparseMatMul {
    /// Creates a new `SparseMatMul`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `transpose_a` attribute.
    pub fn transpose_a<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.transpose_a = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `transpose_b` attribute.
    pub fn transpose_b<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.transpose_b = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `a_is_sparse` attribute.
    pub fn a_is_sparse<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.a_is_sparse = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `b_is_sparse` attribute.
    pub fn b_is_sparse<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.b_is_sparse = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Ta` attribute.
    pub fn Ta<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Ta = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tb` attribute.
    pub fn Tb<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Tb = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SparseMatMul` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        a: O0,
        b: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(a.into(), b.into(), scope)
    }
    fn build_impl(
        &self,
        a: crate::Output,
        b: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SparseMatMul", |nd| {
            nd.add_input(a);
            nd.add_input(b);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.transpose_a {
                nd.set_attr_bool("transpose_a", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.transpose_b {
                nd.set_attr_bool("transpose_b", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.a_is_sparse {
                nd.set_attr_bool("a_is_sparse", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.b_is_sparse {
                nd.set_attr_bool("b_is_sparse", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Ta {
                nd.set_attr_type("Ta", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tb {
                nd.set_attr_type("Tb", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SparseMatMul' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        a: crate::Output,
        b: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SparseMatMulInst> {
        let op = scope.new_operation("SparseMatMul", |builder| {
            builder.add_input(a);
            builder.add_input(b);
            if let ::std::option::Option::Some(value) = &self.transpose_a {
                builder.set_attr_bool("transpose_a", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.transpose_b {
                builder.set_attr_bool("transpose_b", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.a_is_sparse {
                builder.set_attr_bool("a_is_sparse", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.b_is_sparse {
                builder.set_attr_bool("b_is_sparse", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Ta {
                builder.set_attr_type("Ta", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tb {
                builder.set_attr_type("Tb", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SparseMatMulInst { op })
    }
}
impl SparseMatMulInst {
    /// Returns the 'product' Output of this 'SparseMatMul' operation.
    pub fn product(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'a' Input of this 'SparseMatMul' operation.
    pub fn a(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'b' Input of this 'SparseMatMul' operation.
    pub fn b(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<SparseMatMulInst> for crate::Operation {
    fn from(inst: SparseMatMulInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SparseMatMul::new().build(a, b, scope)`.
pub fn sparse_mat_mul<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    a: O0,
    b: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SparseMatMul::new().build(a, b, scope)
}

/// Builder for the `SparseMatrixAdd` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SparseMatrixAdd {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SparseMatrixAdd' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SparseMatrixAddInst {
    /// An instance of a fully built SparseMatrixAdd Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SparseMatrixAdd {
    /// Creates a new `SparseMatrixAdd`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SparseMatrixAdd` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
    >(
        &self,
        a: O0,
        b: O1,
        alpha: O2,
        beta: O3,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(a.into(), b.into(), alpha.into(), beta.into(), scope)
    }
    fn build_impl(
        &self,
        a: crate::Output,
        b: crate::Output,
        alpha: crate::Output,
        beta: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SparseMatrixAdd", |nd| {
            nd.add_input(a);
            nd.add_input(b);
            nd.add_input(alpha);
            nd.add_input(beta);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SparseMatrixAdd' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        a: crate::Output,
        b: crate::Output,
        alpha: crate::Output,
        beta: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SparseMatrixAddInst> {
        let op = scope.new_operation("SparseMatrixAdd", |builder| {
            builder.add_input(a);
            builder.add_input(b);
            builder.add_input(alpha);
            builder.add_input(beta);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SparseMatrixAddInst { op })
    }
}
impl SparseMatrixAddInst {
    /// Returns the 'c' Output of this 'SparseMatrixAdd' operation.
    pub fn c(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'a' Input of this 'SparseMatrixAdd' operation.
    pub fn a(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'b' Input of this 'SparseMatrixAdd' operation.
    pub fn b(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'alpha' Input of this 'SparseMatrixAdd' operation.
    pub fn alpha(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'beta' Input of this 'SparseMatrixAdd' operation.
    pub fn beta(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
}
impl From<SparseMatrixAddInst> for crate::Operation {
    fn from(inst: SparseMatrixAddInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SparseMatrixAdd::new().build(a, b, alpha, beta, scope)`.
pub fn sparse_matrix_add<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
>(
    a: O0,
    b: O1,
    alpha: O2,
    beta: O3,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SparseMatrixAdd::new().build(a, b, alpha, beta, scope)
}

/// Builder for the `SparseMatrixMatMul` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SparseMatrixMatMul {
    T: ::std::option::Option<crate::DataType>,
    transpose_a: ::std::option::Option<bool>,
    transpose_b: ::std::option::Option<bool>,
    adjoint_a: ::std::option::Option<bool>,
    adjoint_b: ::std::option::Option<bool>,
    transpose_output: ::std::option::Option<bool>,
    conjugate_output: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SparseMatrixMatMul' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SparseMatrixMatMulInst {
    /// An instance of a fully built SparseMatrixMatMul Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SparseMatrixMatMul {
    /// Creates a new `SparseMatrixMatMul`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `transpose_a` attribute.
    pub fn transpose_a<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.transpose_a = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `transpose_b` attribute.
    pub fn transpose_b<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.transpose_b = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `adjoint_a` attribute.
    pub fn adjoint_a<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.adjoint_a = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `adjoint_b` attribute.
    pub fn adjoint_b<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.adjoint_b = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `transpose_output` attribute.
    pub fn transpose_output<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.transpose_output = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `conjugate_output` attribute.
    pub fn conjugate_output<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.conjugate_output = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SparseMatrixMatMul` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        a: O0,
        b: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(a.into(), b.into(), scope)
    }
    fn build_impl(
        &self,
        a: crate::Output,
        b: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SparseMatrixMatMul", |nd| {
            nd.add_input(a);
            nd.add_input(b);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.transpose_a {
                nd.set_attr_bool("transpose_a", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.transpose_b {
                nd.set_attr_bool("transpose_b", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.adjoint_a {
                nd.set_attr_bool("adjoint_a", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.adjoint_b {
                nd.set_attr_bool("adjoint_b", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.transpose_output {
                nd.set_attr_bool("transpose_output", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.conjugate_output {
                nd.set_attr_bool("conjugate_output", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SparseMatrixMatMul' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        a: crate::Output,
        b: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SparseMatrixMatMulInst> {
        let op = scope.new_operation("SparseMatrixMatMul", |builder| {
            builder.add_input(a);
            builder.add_input(b);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.transpose_a {
                builder.set_attr_bool("transpose_a", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.transpose_b {
                builder.set_attr_bool("transpose_b", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.adjoint_a {
                builder.set_attr_bool("adjoint_a", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.adjoint_b {
                builder.set_attr_bool("adjoint_b", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.transpose_output {
                builder.set_attr_bool("transpose_output", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.conjugate_output {
                builder.set_attr_bool("conjugate_output", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SparseMatrixMatMulInst { op })
    }
}
impl SparseMatrixMatMulInst {
    /// Returns the 'output' Output of this 'SparseMatrixMatMul' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'a' Input of this 'SparseMatrixMatMul' operation.
    pub fn a(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'b' Input of this 'SparseMatrixMatMul' operation.
    pub fn b(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<SparseMatrixMatMulInst> for crate::Operation {
    fn from(inst: SparseMatrixMatMulInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SparseMatrixMatMul::new().build(a, b, scope)`.
pub fn sparse_matrix_mat_mul<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    a: O0,
    b: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SparseMatrixMatMul::new().build(a, b, scope)
}

/// Builder for the `SparseMatrixMul` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SparseMatrixMul {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SparseMatrixMul' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SparseMatrixMulInst {
    /// An instance of a fully built SparseMatrixMul Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SparseMatrixMul {
    /// Creates a new `SparseMatrixMul`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SparseMatrixMul` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        a: O0,
        b: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(a.into(), b.into(), scope)
    }
    fn build_impl(
        &self,
        a: crate::Output,
        b: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SparseMatrixMul", |nd| {
            nd.add_input(a);
            nd.add_input(b);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SparseMatrixMul' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        a: crate::Output,
        b: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SparseMatrixMulInst> {
        let op = scope.new_operation("SparseMatrixMul", |builder| {
            builder.add_input(a);
            builder.add_input(b);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SparseMatrixMulInst { op })
    }
}
impl SparseMatrixMulInst {
    /// Returns the 'output' Output of this 'SparseMatrixMul' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'a' Input of this 'SparseMatrixMul' operation.
    pub fn a(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'b' Input of this 'SparseMatrixMul' operation.
    pub fn b(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<SparseMatrixMulInst> for crate::Operation {
    fn from(inst: SparseMatrixMulInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SparseMatrixMul::new().build(a, b, scope)`.
pub fn sparse_matrix_mul<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    a: O0,
    b: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SparseMatrixMul::new().build(a, b, scope)
}

/// Builder for the `SparseMatrixNNZ` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SparseMatrixNNZ {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SparseMatrixNNZ' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SparseMatrixNNZInst {
    /// An instance of a fully built SparseMatrixNNZ Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SparseMatrixNNZ {
    /// Creates a new `SparseMatrixNNZ`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SparseMatrixNNZ` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        sparse_matrix: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(sparse_matrix.into(), scope)
    }
    fn build_impl(
        &self,
        sparse_matrix: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SparseMatrixNNZ", |nd| {
            nd.add_input(sparse_matrix);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SparseMatrixNNZ' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        sparse_matrix: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SparseMatrixNNZInst> {
        let op = scope.new_operation("SparseMatrixNNZ", |builder| {
            builder.add_input(sparse_matrix);
            ::std::result::Result::Ok(())
        })?;
        Ok(SparseMatrixNNZInst { op })
    }
}
impl SparseMatrixNNZInst {
    /// Returns the 'nnz' Output of this 'SparseMatrixNNZ' operation.
    pub fn nnz(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'sparse_matrix' Input of this 'SparseMatrixNNZ' operation.
    pub fn sparse_matrix(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<SparseMatrixNNZInst> for crate::Operation {
    fn from(inst: SparseMatrixNNZInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SparseMatrixNNZ::new().build(sparse_matrix, scope)`.
pub fn sparse_matrix_nnz<O0: ::std::convert::Into<crate::Output>>(
    sparse_matrix: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SparseMatrixNNZ::new().build(sparse_matrix, scope)
}

/// Builder for the `SparseMatrixOrderingAMD` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SparseMatrixOrderingAMD {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SparseMatrixOrderingAMD' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SparseMatrixOrderingAMDInst {
    /// An instance of a fully built SparseMatrixOrderingAMD Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SparseMatrixOrderingAMD {
    /// Creates a new `SparseMatrixOrderingAMD`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SparseMatrixOrderingAMD` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SparseMatrixOrderingAMD", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SparseMatrixOrderingAMD' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SparseMatrixOrderingAMDInst> {
        let op = scope.new_operation("SparseMatrixOrderingAMD", |builder| {
            builder.add_input(input);
            ::std::result::Result::Ok(())
        })?;
        Ok(SparseMatrixOrderingAMDInst { op })
    }
}
impl SparseMatrixOrderingAMDInst {
    /// Returns the 'output' Output of this 'SparseMatrixOrderingAMD' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'SparseMatrixOrderingAMD' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<SparseMatrixOrderingAMDInst> for crate::Operation {
    fn from(inst: SparseMatrixOrderingAMDInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SparseMatrixOrderingAMD::new().build(input, scope)`.
pub fn sparse_matrix_ordering_amd<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SparseMatrixOrderingAMD::new().build(input, scope)
}

/// Builder for the `SparseMatrixSoftmax` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SparseMatrixSoftmax {
    type_: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SparseMatrixSoftmax' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SparseMatrixSoftmaxInst {
    /// An instance of a fully built SparseMatrixSoftmax Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SparseMatrixSoftmax {
    /// Creates a new `SparseMatrixSoftmax`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `type` attribute.
    pub fn type_<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.type_ = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SparseMatrixSoftmax` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        logits: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(logits.into(), scope)
    }
    fn build_impl(
        &self,
        logits: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SparseMatrixSoftmax", |nd| {
            nd.add_input(logits);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.type_ {
                nd.set_attr_type("type", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SparseMatrixSoftmax' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        logits: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SparseMatrixSoftmaxInst> {
        let op = scope.new_operation("SparseMatrixSoftmax", |builder| {
            builder.add_input(logits);
            if let ::std::option::Option::Some(value) = &self.type_ {
                builder.set_attr_type("type", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SparseMatrixSoftmaxInst { op })
    }
}
impl SparseMatrixSoftmaxInst {
    /// Returns the 'softmax' Output of this 'SparseMatrixSoftmax' operation.
    pub fn softmax(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'logits' Input of this 'SparseMatrixSoftmax' operation.
    pub fn logits(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<SparseMatrixSoftmaxInst> for crate::Operation {
    fn from(inst: SparseMatrixSoftmaxInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SparseMatrixSoftmax::new().build(logits, scope)`.
pub fn sparse_matrix_softmax<O0: ::std::convert::Into<crate::Output>>(
    logits: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SparseMatrixSoftmax::new().build(logits, scope)
}

/// Builder for the `SparseMatrixSoftmaxGrad` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SparseMatrixSoftmaxGrad {
    type_: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SparseMatrixSoftmaxGrad' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SparseMatrixSoftmaxGradInst {
    /// An instance of a fully built SparseMatrixSoftmaxGrad Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SparseMatrixSoftmaxGrad {
    /// Creates a new `SparseMatrixSoftmaxGrad`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `type` attribute.
    pub fn type_<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.type_ = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SparseMatrixSoftmaxGrad` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        softmax: O0,
        grad_softmax: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(softmax.into(), grad_softmax.into(), scope)
    }
    fn build_impl(
        &self,
        softmax: crate::Output,
        grad_softmax: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SparseMatrixSoftmaxGrad", |nd| {
            nd.add_input(softmax);
            nd.add_input(grad_softmax);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.type_ {
                nd.set_attr_type("type", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SparseMatrixSoftmaxGrad' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        softmax: crate::Output,
        grad_softmax: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SparseMatrixSoftmaxGradInst> {
        let op = scope.new_operation("SparseMatrixSoftmaxGrad", |builder| {
            builder.add_input(softmax);
            builder.add_input(grad_softmax);
            if let ::std::option::Option::Some(value) = &self.type_ {
                builder.set_attr_type("type", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SparseMatrixSoftmaxGradInst { op })
    }
}
impl SparseMatrixSoftmaxGradInst {
    /// Returns the 'gradient' Output of this 'SparseMatrixSoftmaxGrad' operation.
    pub fn gradient(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'softmax' Input of this 'SparseMatrixSoftmaxGrad' operation.
    pub fn softmax(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'grad_softmax' Input of this 'SparseMatrixSoftmaxGrad' operation.
    pub fn grad_softmax(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<SparseMatrixSoftmaxGradInst> for crate::Operation {
    fn from(inst: SparseMatrixSoftmaxGradInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SparseMatrixSoftmaxGrad::new().build(softmax, grad_softmax, scope)`.
pub fn sparse_matrix_softmax_grad<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    softmax: O0,
    grad_softmax: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SparseMatrixSoftmaxGrad::new().build(softmax, grad_softmax, scope)
}

/// Builder for the `SparseMatrixSparseCholesky` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SparseMatrixSparseCholesky {
    type_: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SparseMatrixSparseCholesky' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SparseMatrixSparseCholeskyInst {
    /// An instance of a fully built SparseMatrixSparseCholesky Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SparseMatrixSparseCholesky {
    /// Creates a new `SparseMatrixSparseCholesky`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `type` attribute.
    pub fn type_<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.type_ = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SparseMatrixSparseCholesky` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        permutation: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), permutation.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        permutation: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SparseMatrixSparseCholesky", |nd| {
            nd.add_input(input);
            nd.add_input(permutation);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.type_ {
                nd.set_attr_type("type", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SparseMatrixSparseCholesky' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        permutation: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SparseMatrixSparseCholeskyInst> {
        let op = scope.new_operation("SparseMatrixSparseCholesky", |builder| {
            builder.add_input(input);
            builder.add_input(permutation);
            if let ::std::option::Option::Some(value) = &self.type_ {
                builder.set_attr_type("type", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SparseMatrixSparseCholeskyInst { op })
    }
}
impl SparseMatrixSparseCholeskyInst {
    /// Returns the 'output' Output of this 'SparseMatrixSparseCholesky' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'SparseMatrixSparseCholesky' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'permutation' Input of this 'SparseMatrixSparseCholesky' operation.
    pub fn permutation(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<SparseMatrixSparseCholeskyInst> for crate::Operation {
    fn from(inst: SparseMatrixSparseCholeskyInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SparseMatrixSparseCholesky::new().build(input, permutation, scope)`.
pub fn sparse_matrix_sparse_cholesky<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    input: O0,
    permutation: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SparseMatrixSparseCholesky::new().build(input, permutation, scope)
}

/// Builder for the `SparseMatrixSparseMatMul` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SparseMatrixSparseMatMul {
    type_: ::std::option::Option<crate::DataType>,
    transpose_a: ::std::option::Option<bool>,
    transpose_b: ::std::option::Option<bool>,
    adjoint_a: ::std::option::Option<bool>,
    adjoint_b: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SparseMatrixSparseMatMul' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SparseMatrixSparseMatMulInst {
    /// An instance of a fully built SparseMatrixSparseMatMul Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SparseMatrixSparseMatMul {
    /// Creates a new `SparseMatrixSparseMatMul`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `type` attribute.
    pub fn type_<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.type_ = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `transpose_a` attribute.
    pub fn transpose_a<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.transpose_a = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `transpose_b` attribute.
    pub fn transpose_b<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.transpose_b = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `adjoint_a` attribute.
    pub fn adjoint_a<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.adjoint_a = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `adjoint_b` attribute.
    pub fn adjoint_b<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.adjoint_b = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SparseMatrixSparseMatMul` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        a: O0,
        b: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(a.into(), b.into(), scope)
    }
    fn build_impl(
        &self,
        a: crate::Output,
        b: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SparseMatrixSparseMatMul", |nd| {
            nd.add_input(a);
            nd.add_input(b);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.type_ {
                nd.set_attr_type("type", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.transpose_a {
                nd.set_attr_bool("transpose_a", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.transpose_b {
                nd.set_attr_bool("transpose_b", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.adjoint_a {
                nd.set_attr_bool("adjoint_a", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.adjoint_b {
                nd.set_attr_bool("adjoint_b", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SparseMatrixSparseMatMul' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        a: crate::Output,
        b: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SparseMatrixSparseMatMulInst> {
        let op = scope.new_operation("SparseMatrixSparseMatMul", |builder| {
            builder.add_input(a);
            builder.add_input(b);
            if let ::std::option::Option::Some(value) = &self.type_ {
                builder.set_attr_type("type", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.transpose_a {
                builder.set_attr_bool("transpose_a", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.transpose_b {
                builder.set_attr_bool("transpose_b", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.adjoint_a {
                builder.set_attr_bool("adjoint_a", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.adjoint_b {
                builder.set_attr_bool("adjoint_b", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SparseMatrixSparseMatMulInst { op })
    }
}
impl SparseMatrixSparseMatMulInst {
    /// Returns the 'c' Output of this 'SparseMatrixSparseMatMul' operation.
    pub fn c(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'a' Input of this 'SparseMatrixSparseMatMul' operation.
    pub fn a(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'b' Input of this 'SparseMatrixSparseMatMul' operation.
    pub fn b(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<SparseMatrixSparseMatMulInst> for crate::Operation {
    fn from(inst: SparseMatrixSparseMatMulInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SparseMatrixSparseMatMul::new().build(a, b, scope)`.
pub fn sparse_matrix_sparse_mat_mul<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    a: O0,
    b: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SparseMatrixSparseMatMul::new().build(a, b, scope)
}

/// Builder for the `SparseMatrixTranspose` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SparseMatrixTranspose {
    conjugate: ::std::option::Option<bool>,
    type_: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SparseMatrixTranspose' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SparseMatrixTransposeInst {
    /// An instance of a fully built SparseMatrixTranspose Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SparseMatrixTranspose {
    /// Creates a new `SparseMatrixTranspose`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `conjugate` attribute.
    pub fn conjugate<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.conjugate = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `type` attribute.
    pub fn type_<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.type_ = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SparseMatrixTranspose` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SparseMatrixTranspose", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.conjugate {
                nd.set_attr_bool("conjugate", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.type_ {
                nd.set_attr_type("type", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SparseMatrixTranspose' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SparseMatrixTransposeInst> {
        let op = scope.new_operation("SparseMatrixTranspose", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.conjugate {
                builder.set_attr_bool("conjugate", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.type_ {
                builder.set_attr_type("type", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SparseMatrixTransposeInst { op })
    }
}
impl SparseMatrixTransposeInst {
    /// Returns the 'output' Output of this 'SparseMatrixTranspose' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'SparseMatrixTranspose' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<SparseMatrixTransposeInst> for crate::Operation {
    fn from(inst: SparseMatrixTransposeInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SparseMatrixTranspose::new().build(input, scope)`.
pub fn sparse_matrix_transpose<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SparseMatrixTranspose::new().build(input, scope)
}

/// Builder for the `SparseMatrixZeros` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SparseMatrixZeros {
    type_: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SparseMatrixZeros' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SparseMatrixZerosInst {
    /// An instance of a fully built SparseMatrixZeros Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SparseMatrixZeros {
    /// Creates a new `SparseMatrixZeros`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `type` attribute.
    pub fn type_<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.type_ = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SparseMatrixZeros` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        dense_shape: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(dense_shape.into(), scope)
    }
    fn build_impl(
        &self,
        dense_shape: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SparseMatrixZeros", |nd| {
            nd.add_input(dense_shape);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.type_ {
                nd.set_attr_type("type", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SparseMatrixZeros' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        dense_shape: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SparseMatrixZerosInst> {
        let op = scope.new_operation("SparseMatrixZeros", |builder| {
            builder.add_input(dense_shape);
            if let ::std::option::Option::Some(value) = &self.type_ {
                builder.set_attr_type("type", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SparseMatrixZerosInst { op })
    }
}
impl SparseMatrixZerosInst {
    /// Returns the 'sparse_matrix' Output of this 'SparseMatrixZeros' operation.
    pub fn sparse_matrix(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'dense_shape' Input of this 'SparseMatrixZeros' operation.
    pub fn dense_shape(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<SparseMatrixZerosInst> for crate::Operation {
    fn from(inst: SparseMatrixZerosInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SparseMatrixZeros::new().build(dense_shape, scope)`.
pub fn sparse_matrix_zeros<O0: ::std::convert::Into<crate::Output>>(
    dense_shape: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SparseMatrixZeros::new().build(dense_shape, scope)
}

/// Builder for the `SparseReduceMax` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SparseReduceMax {
    keep_dims: ::std::option::Option<bool>,
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SparseReduceMax' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SparseReduceMaxInst {
    /// An instance of a fully built SparseReduceMax Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SparseReduceMax {
    /// Creates a new `SparseReduceMax`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `keep_dims` attribute.
    pub fn keep_dims<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.keep_dims = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SparseReduceMax` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input_indices: O0,
        input_values: O1,
        input_shape: O2,
        reduction_axes: O3,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            input_indices.into(),
            input_values.into(),
            input_shape.into(),
            reduction_axes.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        input_indices: crate::Output,
        input_values: crate::Output,
        input_shape: crate::Output,
        reduction_axes: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SparseReduceMax", |nd| {
            nd.add_input(input_indices);
            nd.add_input(input_values);
            nd.add_input(input_shape);
            nd.add_input(reduction_axes);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.keep_dims {
                nd.set_attr_bool("keep_dims", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SparseReduceMax' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_indices: crate::Output,
        input_values: crate::Output,
        input_shape: crate::Output,
        reduction_axes: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SparseReduceMaxInst> {
        let op = scope.new_operation("SparseReduceMax", |builder| {
            builder.add_input(input_indices);
            builder.add_input(input_values);
            builder.add_input(input_shape);
            builder.add_input(reduction_axes);
            if let ::std::option::Option::Some(value) = &self.keep_dims {
                builder.set_attr_bool("keep_dims", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SparseReduceMaxInst { op })
    }
}
impl SparseReduceMaxInst {
    /// Returns the 'output' Output of this 'SparseReduceMax' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_indices' Input of this 'SparseReduceMax' operation.
    pub fn input_indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'input_values' Input of this 'SparseReduceMax' operation.
    pub fn input_values(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'input_shape' Input of this 'SparseReduceMax' operation.
    pub fn input_shape(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'reduction_axes' Input of this 'SparseReduceMax' operation.
    pub fn reduction_axes(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
}
impl From<SparseReduceMaxInst> for crate::Operation {
    fn from(inst: SparseReduceMaxInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SparseReduceMax::new().build(input_indices, input_values, input_shape, reduction_axes, scope)`.
pub fn sparse_reduce_max<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
>(
    input_indices: O0,
    input_values: O1,
    input_shape: O2,
    reduction_axes: O3,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SparseReduceMax::new().build(
        input_indices,
        input_values,
        input_shape,
        reduction_axes,
        scope,
    )
}

/// Builder for the `SparseReduceMaxSparse` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SparseReduceMaxSparse {
    keep_dims: ::std::option::Option<bool>,
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SparseReduceMaxSparse' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SparseReduceMaxSparseInst {
    /// An instance of a fully built SparseReduceMaxSparse Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SparseReduceMaxSparse {
    /// Creates a new `SparseReduceMaxSparse`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `keep_dims` attribute.
    pub fn keep_dims<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.keep_dims = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SparseReduceMaxSparse` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input_indices: O0,
        input_values: O1,
        input_shape: O2,
        reduction_axes: O3,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            input_indices.into(),
            input_values.into(),
            input_shape.into(),
            reduction_axes.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        input_indices: crate::Output,
        input_values: crate::Output,
        input_shape: crate::Output,
        reduction_axes: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SparseReduceMaxSparse", |nd| {
            nd.add_input(input_indices);
            nd.add_input(input_values);
            nd.add_input(input_shape);
            nd.add_input(reduction_axes);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.keep_dims {
                nd.set_attr_bool("keep_dims", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SparseReduceMaxSparse' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_indices: crate::Output,
        input_values: crate::Output,
        input_shape: crate::Output,
        reduction_axes: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SparseReduceMaxSparseInst> {
        let op = scope.new_operation("SparseReduceMaxSparse", |builder| {
            builder.add_input(input_indices);
            builder.add_input(input_values);
            builder.add_input(input_shape);
            builder.add_input(reduction_axes);
            if let ::std::option::Option::Some(value) = &self.keep_dims {
                builder.set_attr_bool("keep_dims", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SparseReduceMaxSparseInst { op })
    }
}
impl SparseReduceMaxSparseInst {
    /// Returns the 'output_indices' Output of this 'SparseReduceMaxSparse' operation.
    pub fn output_indices(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'output_values' Output of this 'SparseReduceMaxSparse' operation.
    pub fn output_values(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'output_shape' Output of this 'SparseReduceMaxSparse' operation.
    pub fn output_shape(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns the 'input_indices' Input of this 'SparseReduceMaxSparse' operation.
    pub fn input_indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'input_values' Input of this 'SparseReduceMaxSparse' operation.
    pub fn input_values(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'input_shape' Input of this 'SparseReduceMaxSparse' operation.
    pub fn input_shape(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'reduction_axes' Input of this 'SparseReduceMaxSparse' operation.
    pub fn reduction_axes(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
}
impl From<SparseReduceMaxSparseInst> for crate::Operation {
    fn from(inst: SparseReduceMaxSparseInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SparseReduceMaxSparse::new().build(input_indices, input_values, input_shape, reduction_axes, scope)`.
pub fn sparse_reduce_max_sparse<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
>(
    input_indices: O0,
    input_values: O1,
    input_shape: O2,
    reduction_axes: O3,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SparseReduceMaxSparse::new().build(
        input_indices,
        input_values,
        input_shape,
        reduction_axes,
        scope,
    )
}

/// Builder for the `SparseReduceSum` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SparseReduceSum {
    keep_dims: ::std::option::Option<bool>,
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SparseReduceSum' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SparseReduceSumInst {
    /// An instance of a fully built SparseReduceSum Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SparseReduceSum {
    /// Creates a new `SparseReduceSum`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `keep_dims` attribute.
    pub fn keep_dims<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.keep_dims = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SparseReduceSum` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input_indices: O0,
        input_values: O1,
        input_shape: O2,
        reduction_axes: O3,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            input_indices.into(),
            input_values.into(),
            input_shape.into(),
            reduction_axes.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        input_indices: crate::Output,
        input_values: crate::Output,
        input_shape: crate::Output,
        reduction_axes: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SparseReduceSum", |nd| {
            nd.add_input(input_indices);
            nd.add_input(input_values);
            nd.add_input(input_shape);
            nd.add_input(reduction_axes);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.keep_dims {
                nd.set_attr_bool("keep_dims", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SparseReduceSum' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_indices: crate::Output,
        input_values: crate::Output,
        input_shape: crate::Output,
        reduction_axes: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SparseReduceSumInst> {
        let op = scope.new_operation("SparseReduceSum", |builder| {
            builder.add_input(input_indices);
            builder.add_input(input_values);
            builder.add_input(input_shape);
            builder.add_input(reduction_axes);
            if let ::std::option::Option::Some(value) = &self.keep_dims {
                builder.set_attr_bool("keep_dims", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SparseReduceSumInst { op })
    }
}
impl SparseReduceSumInst {
    /// Returns the 'output' Output of this 'SparseReduceSum' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_indices' Input of this 'SparseReduceSum' operation.
    pub fn input_indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'input_values' Input of this 'SparseReduceSum' operation.
    pub fn input_values(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'input_shape' Input of this 'SparseReduceSum' operation.
    pub fn input_shape(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'reduction_axes' Input of this 'SparseReduceSum' operation.
    pub fn reduction_axes(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
}
impl From<SparseReduceSumInst> for crate::Operation {
    fn from(inst: SparseReduceSumInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SparseReduceSum::new().build(input_indices, input_values, input_shape, reduction_axes, scope)`.
pub fn sparse_reduce_sum<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
>(
    input_indices: O0,
    input_values: O1,
    input_shape: O2,
    reduction_axes: O3,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SparseReduceSum::new().build(
        input_indices,
        input_values,
        input_shape,
        reduction_axes,
        scope,
    )
}

/// Builder for the `SparseReduceSumSparse` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SparseReduceSumSparse {
    keep_dims: ::std::option::Option<bool>,
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SparseReduceSumSparse' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SparseReduceSumSparseInst {
    /// An instance of a fully built SparseReduceSumSparse Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SparseReduceSumSparse {
    /// Creates a new `SparseReduceSumSparse`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `keep_dims` attribute.
    pub fn keep_dims<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.keep_dims = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SparseReduceSumSparse` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input_indices: O0,
        input_values: O1,
        input_shape: O2,
        reduction_axes: O3,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            input_indices.into(),
            input_values.into(),
            input_shape.into(),
            reduction_axes.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        input_indices: crate::Output,
        input_values: crate::Output,
        input_shape: crate::Output,
        reduction_axes: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SparseReduceSumSparse", |nd| {
            nd.add_input(input_indices);
            nd.add_input(input_values);
            nd.add_input(input_shape);
            nd.add_input(reduction_axes);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.keep_dims {
                nd.set_attr_bool("keep_dims", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SparseReduceSumSparse' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_indices: crate::Output,
        input_values: crate::Output,
        input_shape: crate::Output,
        reduction_axes: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SparseReduceSumSparseInst> {
        let op = scope.new_operation("SparseReduceSumSparse", |builder| {
            builder.add_input(input_indices);
            builder.add_input(input_values);
            builder.add_input(input_shape);
            builder.add_input(reduction_axes);
            if let ::std::option::Option::Some(value) = &self.keep_dims {
                builder.set_attr_bool("keep_dims", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SparseReduceSumSparseInst { op })
    }
}
impl SparseReduceSumSparseInst {
    /// Returns the 'output_indices' Output of this 'SparseReduceSumSparse' operation.
    pub fn output_indices(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'output_values' Output of this 'SparseReduceSumSparse' operation.
    pub fn output_values(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'output_shape' Output of this 'SparseReduceSumSparse' operation.
    pub fn output_shape(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns the 'input_indices' Input of this 'SparseReduceSumSparse' operation.
    pub fn input_indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'input_values' Input of this 'SparseReduceSumSparse' operation.
    pub fn input_values(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'input_shape' Input of this 'SparseReduceSumSparse' operation.
    pub fn input_shape(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'reduction_axes' Input of this 'SparseReduceSumSparse' operation.
    pub fn reduction_axes(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
}
impl From<SparseReduceSumSparseInst> for crate::Operation {
    fn from(inst: SparseReduceSumSparseInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SparseReduceSumSparse::new().build(input_indices, input_values, input_shape, reduction_axes, scope)`.
pub fn sparse_reduce_sum_sparse<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
>(
    input_indices: O0,
    input_values: O1,
    input_shape: O2,
    reduction_axes: O3,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SparseReduceSumSparse::new().build(
        input_indices,
        input_values,
        input_shape,
        reduction_axes,
        scope,
    )
}

/// Builder for the `SparseReorder` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SparseReorder {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SparseReorder' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SparseReorderInst {
    /// An instance of a fully built SparseReorder Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SparseReorder {
    /// Creates a new `SparseReorder`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SparseReorder` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input_indices: O0,
        input_values: O1,
        input_shape: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            input_indices.into(),
            input_values.into(),
            input_shape.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        input_indices: crate::Output,
        input_values: crate::Output,
        input_shape: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SparseReorder", |nd| {
            nd.add_input(input_indices);
            nd.add_input(input_values);
            nd.add_input(input_shape);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SparseReorder' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_indices: crate::Output,
        input_values: crate::Output,
        input_shape: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SparseReorderInst> {
        let op = scope.new_operation("SparseReorder", |builder| {
            builder.add_input(input_indices);
            builder.add_input(input_values);
            builder.add_input(input_shape);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SparseReorderInst { op })
    }
}
impl SparseReorderInst {
    /// Returns the 'output_indices' Output of this 'SparseReorder' operation.
    pub fn output_indices(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'output_values' Output of this 'SparseReorder' operation.
    pub fn output_values(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'input_indices' Input of this 'SparseReorder' operation.
    pub fn input_indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'input_values' Input of this 'SparseReorder' operation.
    pub fn input_values(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'input_shape' Input of this 'SparseReorder' operation.
    pub fn input_shape(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<SparseReorderInst> for crate::Operation {
    fn from(inst: SparseReorderInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SparseReorder::new().build(input_indices, input_values, input_shape, scope)`.
pub fn sparse_reorder<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    input_indices: O0,
    input_values: O1,
    input_shape: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SparseReorder::new().build(input_indices, input_values, input_shape, scope)
}

/// Builder for the `SparseReshape` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SparseReshape {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SparseReshape' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SparseReshapeInst {
    /// An instance of a fully built SparseReshape Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SparseReshape {
    /// Creates a new `SparseReshape`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SparseReshape` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input_indices: O0,
        input_shape: O1,
        new_shape: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            input_indices.into(),
            input_shape.into(),
            new_shape.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        input_indices: crate::Output,
        input_shape: crate::Output,
        new_shape: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SparseReshape", |nd| {
            nd.add_input(input_indices);
            nd.add_input(input_shape);
            nd.add_input(new_shape);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SparseReshape' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_indices: crate::Output,
        input_shape: crate::Output,
        new_shape: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SparseReshapeInst> {
        let op = scope.new_operation("SparseReshape", |builder| {
            builder.add_input(input_indices);
            builder.add_input(input_shape);
            builder.add_input(new_shape);
            ::std::result::Result::Ok(())
        })?;
        Ok(SparseReshapeInst { op })
    }
}
impl SparseReshapeInst {
    /// Returns the 'output_indices' Output of this 'SparseReshape' operation.
    pub fn output_indices(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'output_shape' Output of this 'SparseReshape' operation.
    pub fn output_shape(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'input_indices' Input of this 'SparseReshape' operation.
    pub fn input_indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'input_shape' Input of this 'SparseReshape' operation.
    pub fn input_shape(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'new_shape' Input of this 'SparseReshape' operation.
    pub fn new_shape(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<SparseReshapeInst> for crate::Operation {
    fn from(inst: SparseReshapeInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SparseReshape::new().build(input_indices, input_shape, new_shape, scope)`.
pub fn sparse_reshape<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    input_indices: O0,
    input_shape: O1,
    new_shape: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SparseReshape::new().build(input_indices, input_shape, new_shape, scope)
}

/// Builder for the `SparseSegmentMean` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SparseSegmentMean {
    T: ::std::option::Option<crate::DataType>,
    Tidx: ::std::option::Option<crate::DataType>,
    Tsegmentids: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SparseSegmentMean' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SparseSegmentMeanInst {
    /// An instance of a fully built SparseSegmentMean Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SparseSegmentMean {
    /// Creates a new `SparseSegmentMean`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tidx` attribute.
    pub fn Tidx<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Tidx = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tsegmentids` attribute.
    pub fn Tsegmentids<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tsegmentids = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SparseSegmentMean` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        data: O0,
        indices: O1,
        segment_ids: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(data.into(), indices.into(), segment_ids.into(), scope)
    }
    fn build_impl(
        &self,
        data: crate::Output,
        indices: crate::Output,
        segment_ids: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SparseSegmentMean", |nd| {
            nd.add_input(data);
            nd.add_input(indices);
            nd.add_input(segment_ids);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tidx {
                nd.set_attr_type("Tidx", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tsegmentids {
                nd.set_attr_type("Tsegmentids", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SparseSegmentMean' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        data: crate::Output,
        indices: crate::Output,
        segment_ids: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SparseSegmentMeanInst> {
        let op = scope.new_operation("SparseSegmentMean", |builder| {
            builder.add_input(data);
            builder.add_input(indices);
            builder.add_input(segment_ids);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tidx {
                builder.set_attr_type("Tidx", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tsegmentids {
                builder.set_attr_type("Tsegmentids", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SparseSegmentMeanInst { op })
    }
}
impl SparseSegmentMeanInst {
    /// Returns the 'output' Output of this 'SparseSegmentMean' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'data' Input of this 'SparseSegmentMean' operation.
    pub fn data(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'indices' Input of this 'SparseSegmentMean' operation.
    pub fn indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'segment_ids' Input of this 'SparseSegmentMean' operation.
    pub fn segment_ids(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<SparseSegmentMeanInst> for crate::Operation {
    fn from(inst: SparseSegmentMeanInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SparseSegmentMean::new().build(data, indices, segment_ids, scope)`.
pub fn sparse_segment_mean<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    data: O0,
    indices: O1,
    segment_ids: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SparseSegmentMean::new().build(data, indices, segment_ids, scope)
}

/// Builder for the `SparseSegmentMeanGrad` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SparseSegmentMeanGrad {
    T: ::std::option::Option<crate::DataType>,
    Tidx: ::std::option::Option<crate::DataType>,
    Tsegmentids: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SparseSegmentMeanGrad' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SparseSegmentMeanGradInst {
    /// An instance of a fully built SparseSegmentMeanGrad Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SparseSegmentMeanGrad {
    /// Creates a new `SparseSegmentMeanGrad`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tidx` attribute.
    pub fn Tidx<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Tidx = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tsegmentids` attribute.
    pub fn Tsegmentids<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tsegmentids = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SparseSegmentMeanGrad` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
    >(
        &self,
        grad: O0,
        indices: O1,
        segment_ids: O2,
        output_dim0: O3,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            grad.into(),
            indices.into(),
            segment_ids.into(),
            output_dim0.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        grad: crate::Output,
        indices: crate::Output,
        segment_ids: crate::Output,
        output_dim0: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SparseSegmentMeanGrad", |nd| {
            nd.add_input(grad);
            nd.add_input(indices);
            nd.add_input(segment_ids);
            nd.add_input(output_dim0);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tidx {
                nd.set_attr_type("Tidx", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tsegmentids {
                nd.set_attr_type("Tsegmentids", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SparseSegmentMeanGrad' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        grad: crate::Output,
        indices: crate::Output,
        segment_ids: crate::Output,
        output_dim0: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SparseSegmentMeanGradInst> {
        let op = scope.new_operation("SparseSegmentMeanGrad", |builder| {
            builder.add_input(grad);
            builder.add_input(indices);
            builder.add_input(segment_ids);
            builder.add_input(output_dim0);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tidx {
                builder.set_attr_type("Tidx", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tsegmentids {
                builder.set_attr_type("Tsegmentids", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SparseSegmentMeanGradInst { op })
    }
}
impl SparseSegmentMeanGradInst {
    /// Returns the 'output' Output of this 'SparseSegmentMeanGrad' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'grad' Input of this 'SparseSegmentMeanGrad' operation.
    pub fn grad(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'indices' Input of this 'SparseSegmentMeanGrad' operation.
    pub fn indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'segment_ids' Input of this 'SparseSegmentMeanGrad' operation.
    pub fn segment_ids(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'output_dim0' Input of this 'SparseSegmentMeanGrad' operation.
    pub fn output_dim0(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
}
impl From<SparseSegmentMeanGradInst> for crate::Operation {
    fn from(inst: SparseSegmentMeanGradInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SparseSegmentMeanGrad::new().build(grad, indices, segment_ids, output_dim0, scope)`.
pub fn sparse_segment_mean_grad<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
>(
    grad: O0,
    indices: O1,
    segment_ids: O2,
    output_dim0: O3,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SparseSegmentMeanGrad::new().build(grad, indices, segment_ids, output_dim0, scope)
}

/// Builder for the `SparseSegmentMeanWithNumSegments` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SparseSegmentMeanWithNumSegments {
    T: ::std::option::Option<crate::DataType>,
    Tidx: ::std::option::Option<crate::DataType>,
    Tnumsegments: ::std::option::Option<crate::DataType>,
    Tsegmentids: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SparseSegmentMeanWithNumSegments' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SparseSegmentMeanWithNumSegmentsInst {
    /// An instance of a fully built SparseSegmentMeanWithNumSegments Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SparseSegmentMeanWithNumSegments {
    /// Creates a new `SparseSegmentMeanWithNumSegments`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tidx` attribute.
    pub fn Tidx<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Tidx = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tnumsegments` attribute.
    pub fn Tnumsegments<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tnumsegments = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tsegmentids` attribute.
    pub fn Tsegmentids<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tsegmentids = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SparseSegmentMeanWithNumSegments` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
    >(
        &self,
        data: O0,
        indices: O1,
        segment_ids: O2,
        num_segments: O3,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            data.into(),
            indices.into(),
            segment_ids.into(),
            num_segments.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        data: crate::Output,
        indices: crate::Output,
        segment_ids: crate::Output,
        num_segments: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SparseSegmentMeanWithNumSegments", |nd| {
            nd.add_input(data);
            nd.add_input(indices);
            nd.add_input(segment_ids);
            nd.add_input(num_segments);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tidx {
                nd.set_attr_type("Tidx", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tnumsegments {
                nd.set_attr_type("Tnumsegments", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tsegmentids {
                nd.set_attr_type("Tsegmentids", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SparseSegmentMeanWithNumSegments' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        data: crate::Output,
        indices: crate::Output,
        segment_ids: crate::Output,
        num_segments: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SparseSegmentMeanWithNumSegmentsInst> {
        let op = scope.new_operation("SparseSegmentMeanWithNumSegments", |builder| {
            builder.add_input(data);
            builder.add_input(indices);
            builder.add_input(segment_ids);
            builder.add_input(num_segments);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tidx {
                builder.set_attr_type("Tidx", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tnumsegments {
                builder.set_attr_type("Tnumsegments", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tsegmentids {
                builder.set_attr_type("Tsegmentids", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SparseSegmentMeanWithNumSegmentsInst { op })
    }
}
impl SparseSegmentMeanWithNumSegmentsInst {
    /// Returns the 'output' Output of this 'SparseSegmentMeanWithNumSegments' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'data' Input of this 'SparseSegmentMeanWithNumSegments' operation.
    pub fn data(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'indices' Input of this 'SparseSegmentMeanWithNumSegments' operation.
    pub fn indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'segment_ids' Input of this 'SparseSegmentMeanWithNumSegments' operation.
    pub fn segment_ids(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'num_segments' Input of this 'SparseSegmentMeanWithNumSegments' operation.
    pub fn num_segments(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
}
impl From<SparseSegmentMeanWithNumSegmentsInst> for crate::Operation {
    fn from(inst: SparseSegmentMeanWithNumSegmentsInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SparseSegmentMeanWithNumSegments::new().build(data, indices, segment_ids, num_segments, scope)`.
pub fn sparse_segment_mean_with_num_segments<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
>(
    data: O0,
    indices: O1,
    segment_ids: O2,
    num_segments: O3,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SparseSegmentMeanWithNumSegments::new().build(data, indices, segment_ids, num_segments, scope)
}

/// Builder for the `SparseSegmentSqrtN` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SparseSegmentSqrtN {
    T: ::std::option::Option<crate::DataType>,
    Tidx: ::std::option::Option<crate::DataType>,
    Tsegmentids: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SparseSegmentSqrtN' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SparseSegmentSqrtNInst {
    /// An instance of a fully built SparseSegmentSqrtN Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SparseSegmentSqrtN {
    /// Creates a new `SparseSegmentSqrtN`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tidx` attribute.
    pub fn Tidx<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Tidx = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tsegmentids` attribute.
    pub fn Tsegmentids<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tsegmentids = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SparseSegmentSqrtN` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        data: O0,
        indices: O1,
        segment_ids: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(data.into(), indices.into(), segment_ids.into(), scope)
    }
    fn build_impl(
        &self,
        data: crate::Output,
        indices: crate::Output,
        segment_ids: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SparseSegmentSqrtN", |nd| {
            nd.add_input(data);
            nd.add_input(indices);
            nd.add_input(segment_ids);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tidx {
                nd.set_attr_type("Tidx", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tsegmentids {
                nd.set_attr_type("Tsegmentids", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SparseSegmentSqrtN' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        data: crate::Output,
        indices: crate::Output,
        segment_ids: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SparseSegmentSqrtNInst> {
        let op = scope.new_operation("SparseSegmentSqrtN", |builder| {
            builder.add_input(data);
            builder.add_input(indices);
            builder.add_input(segment_ids);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tidx {
                builder.set_attr_type("Tidx", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tsegmentids {
                builder.set_attr_type("Tsegmentids", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SparseSegmentSqrtNInst { op })
    }
}
impl SparseSegmentSqrtNInst {
    /// Returns the 'output' Output of this 'SparseSegmentSqrtN' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'data' Input of this 'SparseSegmentSqrtN' operation.
    pub fn data(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'indices' Input of this 'SparseSegmentSqrtN' operation.
    pub fn indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'segment_ids' Input of this 'SparseSegmentSqrtN' operation.
    pub fn segment_ids(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<SparseSegmentSqrtNInst> for crate::Operation {
    fn from(inst: SparseSegmentSqrtNInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SparseSegmentSqrtN::new().build(data, indices, segment_ids, scope)`.
pub fn sparse_segment_sqrt_n<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    data: O0,
    indices: O1,
    segment_ids: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SparseSegmentSqrtN::new().build(data, indices, segment_ids, scope)
}

/// Builder for the `SparseSegmentSqrtNGrad` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SparseSegmentSqrtNGrad {
    T: ::std::option::Option<crate::DataType>,
    Tidx: ::std::option::Option<crate::DataType>,
    Tsegmentids: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SparseSegmentSqrtNGrad' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SparseSegmentSqrtNGradInst {
    /// An instance of a fully built SparseSegmentSqrtNGrad Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SparseSegmentSqrtNGrad {
    /// Creates a new `SparseSegmentSqrtNGrad`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tidx` attribute.
    pub fn Tidx<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Tidx = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tsegmentids` attribute.
    pub fn Tsegmentids<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tsegmentids = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SparseSegmentSqrtNGrad` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
    >(
        &self,
        grad: O0,
        indices: O1,
        segment_ids: O2,
        output_dim0: O3,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            grad.into(),
            indices.into(),
            segment_ids.into(),
            output_dim0.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        grad: crate::Output,
        indices: crate::Output,
        segment_ids: crate::Output,
        output_dim0: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SparseSegmentSqrtNGrad", |nd| {
            nd.add_input(grad);
            nd.add_input(indices);
            nd.add_input(segment_ids);
            nd.add_input(output_dim0);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tidx {
                nd.set_attr_type("Tidx", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tsegmentids {
                nd.set_attr_type("Tsegmentids", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SparseSegmentSqrtNGrad' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        grad: crate::Output,
        indices: crate::Output,
        segment_ids: crate::Output,
        output_dim0: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SparseSegmentSqrtNGradInst> {
        let op = scope.new_operation("SparseSegmentSqrtNGrad", |builder| {
            builder.add_input(grad);
            builder.add_input(indices);
            builder.add_input(segment_ids);
            builder.add_input(output_dim0);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tidx {
                builder.set_attr_type("Tidx", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tsegmentids {
                builder.set_attr_type("Tsegmentids", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SparseSegmentSqrtNGradInst { op })
    }
}
impl SparseSegmentSqrtNGradInst {
    /// Returns the 'output' Output of this 'SparseSegmentSqrtNGrad' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'grad' Input of this 'SparseSegmentSqrtNGrad' operation.
    pub fn grad(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'indices' Input of this 'SparseSegmentSqrtNGrad' operation.
    pub fn indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'segment_ids' Input of this 'SparseSegmentSqrtNGrad' operation.
    pub fn segment_ids(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'output_dim0' Input of this 'SparseSegmentSqrtNGrad' operation.
    pub fn output_dim0(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
}
impl From<SparseSegmentSqrtNGradInst> for crate::Operation {
    fn from(inst: SparseSegmentSqrtNGradInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SparseSegmentSqrtNGrad::new().build(grad, indices, segment_ids, output_dim0, scope)`.
pub fn sparse_segment_sqrt_ngrad<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
>(
    grad: O0,
    indices: O1,
    segment_ids: O2,
    output_dim0: O3,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SparseSegmentSqrtNGrad::new().build(grad, indices, segment_ids, output_dim0, scope)
}

/// Builder for the `SparseSegmentSqrtNWithNumSegments` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SparseSegmentSqrtNWithNumSegments {
    T: ::std::option::Option<crate::DataType>,
    Tidx: ::std::option::Option<crate::DataType>,
    Tnumsegments: ::std::option::Option<crate::DataType>,
    Tsegmentids: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SparseSegmentSqrtNWithNumSegments' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SparseSegmentSqrtNWithNumSegmentsInst {
    /// An instance of a fully built SparseSegmentSqrtNWithNumSegments Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SparseSegmentSqrtNWithNumSegments {
    /// Creates a new `SparseSegmentSqrtNWithNumSegments`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tidx` attribute.
    pub fn Tidx<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Tidx = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tnumsegments` attribute.
    pub fn Tnumsegments<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tnumsegments = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tsegmentids` attribute.
    pub fn Tsegmentids<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tsegmentids = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SparseSegmentSqrtNWithNumSegments` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
    >(
        &self,
        data: O0,
        indices: O1,
        segment_ids: O2,
        num_segments: O3,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            data.into(),
            indices.into(),
            segment_ids.into(),
            num_segments.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        data: crate::Output,
        indices: crate::Output,
        segment_ids: crate::Output,
        num_segments: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SparseSegmentSqrtNWithNumSegments", |nd| {
            nd.add_input(data);
            nd.add_input(indices);
            nd.add_input(segment_ids);
            nd.add_input(num_segments);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tidx {
                nd.set_attr_type("Tidx", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tnumsegments {
                nd.set_attr_type("Tnumsegments", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tsegmentids {
                nd.set_attr_type("Tsegmentids", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SparseSegmentSqrtNWithNumSegments' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        data: crate::Output,
        indices: crate::Output,
        segment_ids: crate::Output,
        num_segments: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SparseSegmentSqrtNWithNumSegmentsInst> {
        let op = scope.new_operation("SparseSegmentSqrtNWithNumSegments", |builder| {
            builder.add_input(data);
            builder.add_input(indices);
            builder.add_input(segment_ids);
            builder.add_input(num_segments);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tidx {
                builder.set_attr_type("Tidx", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tnumsegments {
                builder.set_attr_type("Tnumsegments", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tsegmentids {
                builder.set_attr_type("Tsegmentids", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SparseSegmentSqrtNWithNumSegmentsInst { op })
    }
}
impl SparseSegmentSqrtNWithNumSegmentsInst {
    /// Returns the 'output' Output of this 'SparseSegmentSqrtNWithNumSegments' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'data' Input of this 'SparseSegmentSqrtNWithNumSegments' operation.
    pub fn data(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'indices' Input of this 'SparseSegmentSqrtNWithNumSegments' operation.
    pub fn indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'segment_ids' Input of this 'SparseSegmentSqrtNWithNumSegments' operation.
    pub fn segment_ids(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'num_segments' Input of this 'SparseSegmentSqrtNWithNumSegments' operation.
    pub fn num_segments(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
}
impl From<SparseSegmentSqrtNWithNumSegmentsInst> for crate::Operation {
    fn from(inst: SparseSegmentSqrtNWithNumSegmentsInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SparseSegmentSqrtNWithNumSegments::new().build(data, indices, segment_ids, num_segments, scope)`.
pub fn sparse_segment_sqrt_nwith_num_segments<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
>(
    data: O0,
    indices: O1,
    segment_ids: O2,
    num_segments: O3,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SparseSegmentSqrtNWithNumSegments::new().build(data, indices, segment_ids, num_segments, scope)
}

/// Builder for the `SparseSegmentSum` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SparseSegmentSum {
    T: ::std::option::Option<crate::DataType>,
    Tidx: ::std::option::Option<crate::DataType>,
    Tsegmentids: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SparseSegmentSum' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SparseSegmentSumInst {
    /// An instance of a fully built SparseSegmentSum Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SparseSegmentSum {
    /// Creates a new `SparseSegmentSum`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tidx` attribute.
    pub fn Tidx<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Tidx = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tsegmentids` attribute.
    pub fn Tsegmentids<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tsegmentids = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SparseSegmentSum` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        data: O0,
        indices: O1,
        segment_ids: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(data.into(), indices.into(), segment_ids.into(), scope)
    }
    fn build_impl(
        &self,
        data: crate::Output,
        indices: crate::Output,
        segment_ids: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SparseSegmentSum", |nd| {
            nd.add_input(data);
            nd.add_input(indices);
            nd.add_input(segment_ids);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tidx {
                nd.set_attr_type("Tidx", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tsegmentids {
                nd.set_attr_type("Tsegmentids", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SparseSegmentSum' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        data: crate::Output,
        indices: crate::Output,
        segment_ids: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SparseSegmentSumInst> {
        let op = scope.new_operation("SparseSegmentSum", |builder| {
            builder.add_input(data);
            builder.add_input(indices);
            builder.add_input(segment_ids);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tidx {
                builder.set_attr_type("Tidx", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tsegmentids {
                builder.set_attr_type("Tsegmentids", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SparseSegmentSumInst { op })
    }
}
impl SparseSegmentSumInst {
    /// Returns the 'output' Output of this 'SparseSegmentSum' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'data' Input of this 'SparseSegmentSum' operation.
    pub fn data(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'indices' Input of this 'SparseSegmentSum' operation.
    pub fn indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'segment_ids' Input of this 'SparseSegmentSum' operation.
    pub fn segment_ids(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<SparseSegmentSumInst> for crate::Operation {
    fn from(inst: SparseSegmentSumInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SparseSegmentSum::new().build(data, indices, segment_ids, scope)`.
pub fn sparse_segment_sum<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    data: O0,
    indices: O1,
    segment_ids: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SparseSegmentSum::new().build(data, indices, segment_ids, scope)
}

/// Builder for the `SparseSegmentSumGrad` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SparseSegmentSumGrad {
    T: ::std::option::Option<crate::DataType>,
    Tidx: ::std::option::Option<crate::DataType>,
    Tsegmentids: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SparseSegmentSumGrad' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SparseSegmentSumGradInst {
    /// An instance of a fully built SparseSegmentSumGrad Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SparseSegmentSumGrad {
    /// Creates a new `SparseSegmentSumGrad`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tidx` attribute.
    pub fn Tidx<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Tidx = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tsegmentids` attribute.
    pub fn Tsegmentids<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tsegmentids = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SparseSegmentSumGrad` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
    >(
        &self,
        grad: O0,
        indices: O1,
        segment_ids: O2,
        output_dim0: O3,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            grad.into(),
            indices.into(),
            segment_ids.into(),
            output_dim0.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        grad: crate::Output,
        indices: crate::Output,
        segment_ids: crate::Output,
        output_dim0: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SparseSegmentSumGrad", |nd| {
            nd.add_input(grad);
            nd.add_input(indices);
            nd.add_input(segment_ids);
            nd.add_input(output_dim0);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tidx {
                nd.set_attr_type("Tidx", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tsegmentids {
                nd.set_attr_type("Tsegmentids", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SparseSegmentSumGrad' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        grad: crate::Output,
        indices: crate::Output,
        segment_ids: crate::Output,
        output_dim0: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SparseSegmentSumGradInst> {
        let op = scope.new_operation("SparseSegmentSumGrad", |builder| {
            builder.add_input(grad);
            builder.add_input(indices);
            builder.add_input(segment_ids);
            builder.add_input(output_dim0);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tidx {
                builder.set_attr_type("Tidx", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tsegmentids {
                builder.set_attr_type("Tsegmentids", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SparseSegmentSumGradInst { op })
    }
}
impl SparseSegmentSumGradInst {
    /// Returns the 'output' Output of this 'SparseSegmentSumGrad' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'grad' Input of this 'SparseSegmentSumGrad' operation.
    pub fn grad(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'indices' Input of this 'SparseSegmentSumGrad' operation.
    pub fn indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'segment_ids' Input of this 'SparseSegmentSumGrad' operation.
    pub fn segment_ids(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'output_dim0' Input of this 'SparseSegmentSumGrad' operation.
    pub fn output_dim0(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
}
impl From<SparseSegmentSumGradInst> for crate::Operation {
    fn from(inst: SparseSegmentSumGradInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SparseSegmentSumGrad::new().build(grad, indices, segment_ids, output_dim0, scope)`.
pub fn sparse_segment_sum_grad<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
>(
    grad: O0,
    indices: O1,
    segment_ids: O2,
    output_dim0: O3,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SparseSegmentSumGrad::new().build(grad, indices, segment_ids, output_dim0, scope)
}

/// Builder for the `SparseSegmentSumWithNumSegments` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SparseSegmentSumWithNumSegments {
    T: ::std::option::Option<crate::DataType>,
    Tidx: ::std::option::Option<crate::DataType>,
    Tnumsegments: ::std::option::Option<crate::DataType>,
    Tsegmentids: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SparseSegmentSumWithNumSegments' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SparseSegmentSumWithNumSegmentsInst {
    /// An instance of a fully built SparseSegmentSumWithNumSegments Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SparseSegmentSumWithNumSegments {
    /// Creates a new `SparseSegmentSumWithNumSegments`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tidx` attribute.
    pub fn Tidx<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Tidx = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tnumsegments` attribute.
    pub fn Tnumsegments<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tnumsegments = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tsegmentids` attribute.
    pub fn Tsegmentids<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tsegmentids = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SparseSegmentSumWithNumSegments` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
    >(
        &self,
        data: O0,
        indices: O1,
        segment_ids: O2,
        num_segments: O3,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            data.into(),
            indices.into(),
            segment_ids.into(),
            num_segments.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        data: crate::Output,
        indices: crate::Output,
        segment_ids: crate::Output,
        num_segments: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SparseSegmentSumWithNumSegments", |nd| {
            nd.add_input(data);
            nd.add_input(indices);
            nd.add_input(segment_ids);
            nd.add_input(num_segments);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tidx {
                nd.set_attr_type("Tidx", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tnumsegments {
                nd.set_attr_type("Tnumsegments", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tsegmentids {
                nd.set_attr_type("Tsegmentids", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SparseSegmentSumWithNumSegments' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        data: crate::Output,
        indices: crate::Output,
        segment_ids: crate::Output,
        num_segments: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SparseSegmentSumWithNumSegmentsInst> {
        let op = scope.new_operation("SparseSegmentSumWithNumSegments", |builder| {
            builder.add_input(data);
            builder.add_input(indices);
            builder.add_input(segment_ids);
            builder.add_input(num_segments);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tidx {
                builder.set_attr_type("Tidx", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tnumsegments {
                builder.set_attr_type("Tnumsegments", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tsegmentids {
                builder.set_attr_type("Tsegmentids", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SparseSegmentSumWithNumSegmentsInst { op })
    }
}
impl SparseSegmentSumWithNumSegmentsInst {
    /// Returns the 'output' Output of this 'SparseSegmentSumWithNumSegments' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'data' Input of this 'SparseSegmentSumWithNumSegments' operation.
    pub fn data(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'indices' Input of this 'SparseSegmentSumWithNumSegments' operation.
    pub fn indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'segment_ids' Input of this 'SparseSegmentSumWithNumSegments' operation.
    pub fn segment_ids(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'num_segments' Input of this 'SparseSegmentSumWithNumSegments' operation.
    pub fn num_segments(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
}
impl From<SparseSegmentSumWithNumSegmentsInst> for crate::Operation {
    fn from(inst: SparseSegmentSumWithNumSegmentsInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SparseSegmentSumWithNumSegments::new().build(data, indices, segment_ids, num_segments, scope)`.
pub fn sparse_segment_sum_with_num_segments<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
>(
    data: O0,
    indices: O1,
    segment_ids: O2,
    num_segments: O3,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SparseSegmentSumWithNumSegments::new().build(data, indices, segment_ids, num_segments, scope)
}

/// Builder for the `SparseSlice` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SparseSlice {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SparseSlice' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SparseSliceInst {
    /// An instance of a fully built SparseSlice Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SparseSlice {
    /// Creates a new `SparseSlice`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SparseSlice` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
    >(
        &self,
        indices: O0,
        values: O1,
        shape: O2,
        start: O3,
        size: O4,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            indices.into(),
            values.into(),
            shape.into(),
            start.into(),
            size.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        indices: crate::Output,
        values: crate::Output,
        shape: crate::Output,
        start: crate::Output,
        size: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SparseSlice", |nd| {
            nd.add_input(indices);
            nd.add_input(values);
            nd.add_input(shape);
            nd.add_input(start);
            nd.add_input(size);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SparseSlice' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        indices: crate::Output,
        values: crate::Output,
        shape: crate::Output,
        start: crate::Output,
        size: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SparseSliceInst> {
        let op = scope.new_operation("SparseSlice", |builder| {
            builder.add_input(indices);
            builder.add_input(values);
            builder.add_input(shape);
            builder.add_input(start);
            builder.add_input(size);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SparseSliceInst { op })
    }
}
impl SparseSliceInst {
    /// Returns the 'output_indices' Output of this 'SparseSlice' operation.
    pub fn output_indices(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'output_values' Output of this 'SparseSlice' operation.
    pub fn output_values(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'output_shape' Output of this 'SparseSlice' operation.
    pub fn output_shape(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns the 'indices' Input of this 'SparseSlice' operation.
    pub fn indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'values' Input of this 'SparseSlice' operation.
    pub fn values(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'shape' Input of this 'SparseSlice' operation.
    pub fn shape(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'start' Input of this 'SparseSlice' operation.
    pub fn start(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'size' Input of this 'SparseSlice' operation.
    pub fn size(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
}
impl From<SparseSliceInst> for crate::Operation {
    fn from(inst: SparseSliceInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SparseSlice::new().build(indices, values, shape, start, size, scope)`.
pub fn sparse_slice<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
>(
    indices: O0,
    values: O1,
    shape: O2,
    start: O3,
    size: O4,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SparseSlice::new().build(indices, values, shape, start, size, scope)
}

/// Builder for the `SparseSliceGrad` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SparseSliceGrad {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SparseSliceGrad' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SparseSliceGradInst {
    /// An instance of a fully built SparseSliceGrad Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SparseSliceGrad {
    /// Creates a new `SparseSliceGrad`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SparseSliceGrad` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
    >(
        &self,
        backprop_val_grad: O0,
        input_indices: O1,
        input_start: O2,
        output_indices: O3,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            backprop_val_grad.into(),
            input_indices.into(),
            input_start.into(),
            output_indices.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        backprop_val_grad: crate::Output,
        input_indices: crate::Output,
        input_start: crate::Output,
        output_indices: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SparseSliceGrad", |nd| {
            nd.add_input(backprop_val_grad);
            nd.add_input(input_indices);
            nd.add_input(input_start);
            nd.add_input(output_indices);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SparseSliceGrad' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        backprop_val_grad: crate::Output,
        input_indices: crate::Output,
        input_start: crate::Output,
        output_indices: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SparseSliceGradInst> {
        let op = scope.new_operation("SparseSliceGrad", |builder| {
            builder.add_input(backprop_val_grad);
            builder.add_input(input_indices);
            builder.add_input(input_start);
            builder.add_input(output_indices);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SparseSliceGradInst { op })
    }
}
impl SparseSliceGradInst {
    /// Returns the 'val_grad' Output of this 'SparseSliceGrad' operation.
    pub fn val_grad(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'backprop_val_grad' Input of this 'SparseSliceGrad' operation.
    pub fn backprop_val_grad(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'input_indices' Input of this 'SparseSliceGrad' operation.
    pub fn input_indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'input_start' Input of this 'SparseSliceGrad' operation.
    pub fn input_start(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'output_indices' Input of this 'SparseSliceGrad' operation.
    pub fn output_indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
}
impl From<SparseSliceGradInst> for crate::Operation {
    fn from(inst: SparseSliceGradInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SparseSliceGrad::new().build(backprop_val_grad, input_indices, input_start, output_indices, scope)`.
pub fn sparse_slice_grad<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
>(
    backprop_val_grad: O0,
    input_indices: O1,
    input_start: O2,
    output_indices: O3,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SparseSliceGrad::new().build(
        backprop_val_grad,
        input_indices,
        input_start,
        output_indices,
        scope,
    )
}

/// Builder for the `SparseSoftmax` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SparseSoftmax {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SparseSoftmax' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SparseSoftmaxInst {
    /// An instance of a fully built SparseSoftmax Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SparseSoftmax {
    /// Creates a new `SparseSoftmax`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SparseSoftmax` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        sp_indices: O0,
        sp_values: O1,
        sp_shape: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(sp_indices.into(), sp_values.into(), sp_shape.into(), scope)
    }
    fn build_impl(
        &self,
        sp_indices: crate::Output,
        sp_values: crate::Output,
        sp_shape: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SparseSoftmax", |nd| {
            nd.add_input(sp_indices);
            nd.add_input(sp_values);
            nd.add_input(sp_shape);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SparseSoftmax' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        sp_indices: crate::Output,
        sp_values: crate::Output,
        sp_shape: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SparseSoftmaxInst> {
        let op = scope.new_operation("SparseSoftmax", |builder| {
            builder.add_input(sp_indices);
            builder.add_input(sp_values);
            builder.add_input(sp_shape);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SparseSoftmaxInst { op })
    }
}
impl SparseSoftmaxInst {
    /// Returns the 'output' Output of this 'SparseSoftmax' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'sp_indices' Input of this 'SparseSoftmax' operation.
    pub fn sp_indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'sp_values' Input of this 'SparseSoftmax' operation.
    pub fn sp_values(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'sp_shape' Input of this 'SparseSoftmax' operation.
    pub fn sp_shape(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<SparseSoftmaxInst> for crate::Operation {
    fn from(inst: SparseSoftmaxInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SparseSoftmax::new().build(sp_indices, sp_values, sp_shape, scope)`.
pub fn sparse_softmax<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    sp_indices: O0,
    sp_values: O1,
    sp_shape: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SparseSoftmax::new().build(sp_indices, sp_values, sp_shape, scope)
}

/// Builder for the `SparseSoftmaxCrossEntropyWithLogits` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SparseSoftmaxCrossEntropyWithLogits {
    T: ::std::option::Option<crate::DataType>,
    Tlabels: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SparseSoftmaxCrossEntropyWithLogits' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SparseSoftmaxCrossEntropyWithLogitsInst {
    /// An instance of a fully built SparseSoftmaxCrossEntropyWithLogits Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SparseSoftmaxCrossEntropyWithLogits {
    /// Creates a new `SparseSoftmaxCrossEntropyWithLogits`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tlabels` attribute.
    pub fn Tlabels<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tlabels = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SparseSoftmaxCrossEntropyWithLogits` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        features: O0,
        labels: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(features.into(), labels.into(), scope)
    }
    fn build_impl(
        &self,
        features: crate::Output,
        labels: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SparseSoftmaxCrossEntropyWithLogits", |nd| {
            nd.add_input(features);
            nd.add_input(labels);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tlabels {
                nd.set_attr_type("Tlabels", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SparseSoftmaxCrossEntropyWithLogits' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        features: crate::Output,
        labels: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SparseSoftmaxCrossEntropyWithLogitsInst> {
        let op = scope.new_operation("SparseSoftmaxCrossEntropyWithLogits", |builder| {
            builder.add_input(features);
            builder.add_input(labels);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tlabels {
                builder.set_attr_type("Tlabels", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SparseSoftmaxCrossEntropyWithLogitsInst { op })
    }
}
impl SparseSoftmaxCrossEntropyWithLogitsInst {
    /// Returns the 'loss' Output of this 'SparseSoftmaxCrossEntropyWithLogits' operation.
    pub fn loss(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'backprop' Output of this 'SparseSoftmaxCrossEntropyWithLogits' operation.
    pub fn backprop(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'features' Input of this 'SparseSoftmaxCrossEntropyWithLogits' operation.
    pub fn features(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'labels' Input of this 'SparseSoftmaxCrossEntropyWithLogits' operation.
    pub fn labels(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<SparseSoftmaxCrossEntropyWithLogitsInst> for crate::Operation {
    fn from(inst: SparseSoftmaxCrossEntropyWithLogitsInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SparseSoftmaxCrossEntropyWithLogits::new().build(features, labels, scope)`.
pub fn sparse_softmax_cross_entropy_with_logits<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    features: O0,
    labels: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SparseSoftmaxCrossEntropyWithLogits::new().build(features, labels, scope)
}

/// Builder for the `SparseSparseMaximum` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SparseSparseMaximum {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SparseSparseMaximum' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SparseSparseMaximumInst {
    /// An instance of a fully built SparseSparseMaximum Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SparseSparseMaximum {
    /// Creates a new `SparseSparseMaximum`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SparseSparseMaximum` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
    >(
        &self,
        a_indices: O0,
        a_values: O1,
        a_shape: O2,
        b_indices: O3,
        b_values: O4,
        b_shape: O5,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            a_indices.into(),
            a_values.into(),
            a_shape.into(),
            b_indices.into(),
            b_values.into(),
            b_shape.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        a_indices: crate::Output,
        a_values: crate::Output,
        a_shape: crate::Output,
        b_indices: crate::Output,
        b_values: crate::Output,
        b_shape: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SparseSparseMaximum", |nd| {
            nd.add_input(a_indices);
            nd.add_input(a_values);
            nd.add_input(a_shape);
            nd.add_input(b_indices);
            nd.add_input(b_values);
            nd.add_input(b_shape);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SparseSparseMaximum' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        a_indices: crate::Output,
        a_values: crate::Output,
        a_shape: crate::Output,
        b_indices: crate::Output,
        b_values: crate::Output,
        b_shape: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SparseSparseMaximumInst> {
        let op = scope.new_operation("SparseSparseMaximum", |builder| {
            builder.add_input(a_indices);
            builder.add_input(a_values);
            builder.add_input(a_shape);
            builder.add_input(b_indices);
            builder.add_input(b_values);
            builder.add_input(b_shape);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SparseSparseMaximumInst { op })
    }
}
impl SparseSparseMaximumInst {
    /// Returns the 'output_indices' Output of this 'SparseSparseMaximum' operation.
    pub fn output_indices(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'output_values' Output of this 'SparseSparseMaximum' operation.
    pub fn output_values(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'a_indices' Input of this 'SparseSparseMaximum' operation.
    pub fn a_indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'a_values' Input of this 'SparseSparseMaximum' operation.
    pub fn a_values(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'a_shape' Input of this 'SparseSparseMaximum' operation.
    pub fn a_shape(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'b_indices' Input of this 'SparseSparseMaximum' operation.
    pub fn b_indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'b_values' Input of this 'SparseSparseMaximum' operation.
    pub fn b_values(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
    /// Returns the 'b_shape' Input of this 'SparseSparseMaximum' operation.
    pub fn b_shape(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 5,
        }
    }
}
impl From<SparseSparseMaximumInst> for crate::Operation {
    fn from(inst: SparseSparseMaximumInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SparseSparseMaximum::new().build(a_indices, a_values, a_shape, b_indices, b_values, b_shape, scope)`.
pub fn sparse_sparse_maximum<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
>(
    a_indices: O0,
    a_values: O1,
    a_shape: O2,
    b_indices: O3,
    b_values: O4,
    b_shape: O5,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SparseSparseMaximum::new().build(
        a_indices, a_values, a_shape, b_indices, b_values, b_shape, scope,
    )
}

/// Builder for the `SparseSparseMinimum` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SparseSparseMinimum {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SparseSparseMinimum' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SparseSparseMinimumInst {
    /// An instance of a fully built SparseSparseMinimum Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SparseSparseMinimum {
    /// Creates a new `SparseSparseMinimum`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SparseSparseMinimum` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
    >(
        &self,
        a_indices: O0,
        a_values: O1,
        a_shape: O2,
        b_indices: O3,
        b_values: O4,
        b_shape: O5,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            a_indices.into(),
            a_values.into(),
            a_shape.into(),
            b_indices.into(),
            b_values.into(),
            b_shape.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        a_indices: crate::Output,
        a_values: crate::Output,
        a_shape: crate::Output,
        b_indices: crate::Output,
        b_values: crate::Output,
        b_shape: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SparseSparseMinimum", |nd| {
            nd.add_input(a_indices);
            nd.add_input(a_values);
            nd.add_input(a_shape);
            nd.add_input(b_indices);
            nd.add_input(b_values);
            nd.add_input(b_shape);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SparseSparseMinimum' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        a_indices: crate::Output,
        a_values: crate::Output,
        a_shape: crate::Output,
        b_indices: crate::Output,
        b_values: crate::Output,
        b_shape: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SparseSparseMinimumInst> {
        let op = scope.new_operation("SparseSparseMinimum", |builder| {
            builder.add_input(a_indices);
            builder.add_input(a_values);
            builder.add_input(a_shape);
            builder.add_input(b_indices);
            builder.add_input(b_values);
            builder.add_input(b_shape);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SparseSparseMinimumInst { op })
    }
}
impl SparseSparseMinimumInst {
    /// Returns the 'output_indices' Output of this 'SparseSparseMinimum' operation.
    pub fn output_indices(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'output_values' Output of this 'SparseSparseMinimum' operation.
    pub fn output_values(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'a_indices' Input of this 'SparseSparseMinimum' operation.
    pub fn a_indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'a_values' Input of this 'SparseSparseMinimum' operation.
    pub fn a_values(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'a_shape' Input of this 'SparseSparseMinimum' operation.
    pub fn a_shape(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'b_indices' Input of this 'SparseSparseMinimum' operation.
    pub fn b_indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'b_values' Input of this 'SparseSparseMinimum' operation.
    pub fn b_values(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
    /// Returns the 'b_shape' Input of this 'SparseSparseMinimum' operation.
    pub fn b_shape(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 5,
        }
    }
}
impl From<SparseSparseMinimumInst> for crate::Operation {
    fn from(inst: SparseSparseMinimumInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SparseSparseMinimum::new().build(a_indices, a_values, a_shape, b_indices, b_values, b_shape, scope)`.
pub fn sparse_sparse_minimum<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
>(
    a_indices: O0,
    a_values: O1,
    a_shape: O2,
    b_indices: O3,
    b_values: O4,
    b_shape: O5,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SparseSparseMinimum::new().build(
        a_indices, a_values, a_shape, b_indices, b_values, b_shape, scope,
    )
}

/// Builder for the `SparseSplit` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SparseSplit {
    num_split: ::std::option::Option<i64>,
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SparseSplit' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SparseSplitInst {
    /// An instance of a fully built SparseSplit Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SparseSplit {
    /// Creates a new `SparseSplit`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `num_split` attribute.
    pub fn num_split<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.num_split = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SparseSplit` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
    >(
        &self,
        split_dim: O0,
        indices: O1,
        values: O2,
        shape: O3,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            split_dim.into(),
            indices.into(),
            values.into(),
            shape.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        split_dim: crate::Output,
        indices: crate::Output,
        values: crate::Output,
        shape: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SparseSplit", |nd| {
            nd.add_input(split_dim);
            nd.add_input(indices);
            nd.add_input(values);
            nd.add_input(shape);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.num_split {
                nd.set_attr_int("num_split", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SparseSplit' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        split_dim: crate::Output,
        indices: crate::Output,
        values: crate::Output,
        shape: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SparseSplitInst> {
        let op = scope.new_operation("SparseSplit", |builder| {
            builder.add_input(split_dim);
            builder.add_input(indices);
            builder.add_input(values);
            builder.add_input(shape);
            if let ::std::option::Option::Some(value) = &self.num_split {
                builder.set_attr_int("num_split", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SparseSplitInst { op })
    }
}
impl SparseSplitInst {
    /// Returns a Vector of output_indices for 'output_indices' Output of this SparseSplit operation.
    pub fn output_indices(&self) -> crate::Result<Vec<crate::Output>> {
        let mut Outputs = vec![];
        for i in 0..self.op.get_attr_int("num_split")? as i32 {
            Outputs.push(crate::Output {
                operation: self.op.clone(),
                index: i,
            });
        }
        Ok(Outputs)
    }
    /// Returns a Vector of output_values for 'output_values' Output of this SparseSplit operation.
    pub fn output_values(&self) -> crate::Result<Vec<crate::Output>> {
        let dynamic_offset = (self.op.get_attr_int("num_split")? + 1) as i32;
        let mut Outputs = vec![];
        for i in dynamic_offset..dynamic_offset + self.op.get_attr_int("num_split")? as i32 {
            Outputs.push(crate::Output {
                operation: self.op.clone(),
                index: i,
            });
        }
        Ok(Outputs)
    }
    /// Returns a Vector of output_shape for 'output_shape' Output of this SparseSplit operation.
    pub fn output_shape(&self) -> crate::Result<Vec<crate::Output>> {
        let dynamic_offset = (2 * self.op.get_attr_int("num_split")? + 2) as i32;
        let mut Outputs = vec![];
        for i in dynamic_offset..dynamic_offset + self.op.get_attr_int("num_split")? as i32 {
            Outputs.push(crate::Output {
                operation: self.op.clone(),
                index: i,
            });
        }
        Ok(Outputs)
    }
    /// Returns the 'split_dim' Input of this 'SparseSplit' operation.
    pub fn split_dim(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'indices' Input of this 'SparseSplit' operation.
    pub fn indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'values' Input of this 'SparseSplit' operation.
    pub fn values(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'shape' Input of this 'SparseSplit' operation.
    pub fn shape(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
}
impl From<SparseSplitInst> for crate::Operation {
    fn from(inst: SparseSplitInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SparseSplit::new().build(split_dim, indices, values, shape, scope)`.
pub fn sparse_split<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
>(
    split_dim: O0,
    indices: O1,
    values: O2,
    shape: O3,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SparseSplit::new().build(split_dim, indices, values, shape, scope)
}

/// Builder for the `SparseTensorDenseAdd` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SparseTensorDenseAdd {
    T: ::std::option::Option<crate::DataType>,
    Tindices: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SparseTensorDenseAdd' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SparseTensorDenseAddInst {
    /// An instance of a fully built SparseTensorDenseAdd Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SparseTensorDenseAdd {
    /// Creates a new `SparseTensorDenseAdd`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tindices` attribute.
    pub fn Tindices<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tindices = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SparseTensorDenseAdd` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
    >(
        &self,
        a_indices: O0,
        a_values: O1,
        a_shape: O2,
        b: O3,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            a_indices.into(),
            a_values.into(),
            a_shape.into(),
            b.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        a_indices: crate::Output,
        a_values: crate::Output,
        a_shape: crate::Output,
        b: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SparseTensorDenseAdd", |nd| {
            nd.add_input(a_indices);
            nd.add_input(a_values);
            nd.add_input(a_shape);
            nd.add_input(b);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                nd.set_attr_type("Tindices", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SparseTensorDenseAdd' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        a_indices: crate::Output,
        a_values: crate::Output,
        a_shape: crate::Output,
        b: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SparseTensorDenseAddInst> {
        let op = scope.new_operation("SparseTensorDenseAdd", |builder| {
            builder.add_input(a_indices);
            builder.add_input(a_values);
            builder.add_input(a_shape);
            builder.add_input(b);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                builder.set_attr_type("Tindices", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SparseTensorDenseAddInst { op })
    }
}
impl SparseTensorDenseAddInst {
    /// Returns the 'output' Output of this 'SparseTensorDenseAdd' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'a_indices' Input of this 'SparseTensorDenseAdd' operation.
    pub fn a_indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'a_values' Input of this 'SparseTensorDenseAdd' operation.
    pub fn a_values(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'a_shape' Input of this 'SparseTensorDenseAdd' operation.
    pub fn a_shape(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'b' Input of this 'SparseTensorDenseAdd' operation.
    pub fn b(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
}
impl From<SparseTensorDenseAddInst> for crate::Operation {
    fn from(inst: SparseTensorDenseAddInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SparseTensorDenseAdd::new().build(a_indices, a_values, a_shape, b, scope)`.
pub fn sparse_tensor_dense_add<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
>(
    a_indices: O0,
    a_values: O1,
    a_shape: O2,
    b: O3,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SparseTensorDenseAdd::new().build(a_indices, a_values, a_shape, b, scope)
}

/// Builder for the `SparseTensorDenseMatMul` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SparseTensorDenseMatMul {
    T: ::std::option::Option<crate::DataType>,
    Tindices: ::std::option::Option<crate::DataType>,
    adjoint_a: ::std::option::Option<bool>,
    adjoint_b: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SparseTensorDenseMatMul' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SparseTensorDenseMatMulInst {
    /// An instance of a fully built SparseTensorDenseMatMul Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SparseTensorDenseMatMul {
    /// Creates a new `SparseTensorDenseMatMul`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tindices` attribute.
    pub fn Tindices<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tindices = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `adjoint_a` attribute.
    pub fn adjoint_a<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.adjoint_a = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `adjoint_b` attribute.
    pub fn adjoint_b<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.adjoint_b = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SparseTensorDenseMatMul` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
    >(
        &self,
        a_indices: O0,
        a_values: O1,
        a_shape: O2,
        b: O3,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            a_indices.into(),
            a_values.into(),
            a_shape.into(),
            b.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        a_indices: crate::Output,
        a_values: crate::Output,
        a_shape: crate::Output,
        b: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SparseTensorDenseMatMul", |nd| {
            nd.add_input(a_indices);
            nd.add_input(a_values);
            nd.add_input(a_shape);
            nd.add_input(b);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                nd.set_attr_type("Tindices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.adjoint_a {
                nd.set_attr_bool("adjoint_a", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.adjoint_b {
                nd.set_attr_bool("adjoint_b", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SparseTensorDenseMatMul' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        a_indices: crate::Output,
        a_values: crate::Output,
        a_shape: crate::Output,
        b: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SparseTensorDenseMatMulInst> {
        let op = scope.new_operation("SparseTensorDenseMatMul", |builder| {
            builder.add_input(a_indices);
            builder.add_input(a_values);
            builder.add_input(a_shape);
            builder.add_input(b);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                builder.set_attr_type("Tindices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.adjoint_a {
                builder.set_attr_bool("adjoint_a", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.adjoint_b {
                builder.set_attr_bool("adjoint_b", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SparseTensorDenseMatMulInst { op })
    }
}
impl SparseTensorDenseMatMulInst {
    /// Returns the 'product' Output of this 'SparseTensorDenseMatMul' operation.
    pub fn product(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'a_indices' Input of this 'SparseTensorDenseMatMul' operation.
    pub fn a_indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'a_values' Input of this 'SparseTensorDenseMatMul' operation.
    pub fn a_values(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'a_shape' Input of this 'SparseTensorDenseMatMul' operation.
    pub fn a_shape(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'b' Input of this 'SparseTensorDenseMatMul' operation.
    pub fn b(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
}
impl From<SparseTensorDenseMatMulInst> for crate::Operation {
    fn from(inst: SparseTensorDenseMatMulInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SparseTensorDenseMatMul::new().build(a_indices, a_values, a_shape, b, scope)`.
pub fn sparse_tensor_dense_mat_mul<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
>(
    a_indices: O0,
    a_values: O1,
    a_shape: O2,
    b: O3,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SparseTensorDenseMatMul::new().build(a_indices, a_values, a_shape, b, scope)
}

/// Builder for the `SparseTensorSliceDataset` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SparseTensorSliceDataset {
    Tvalues: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SparseTensorSliceDataset' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SparseTensorSliceDatasetInst {
    /// An instance of a fully built SparseTensorSliceDataset Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SparseTensorSliceDataset {
    /// Creates a new `SparseTensorSliceDataset`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `Tvalues` attribute.
    pub fn Tvalues<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tvalues = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SparseTensorSliceDataset` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        indices: O0,
        values: O1,
        dense_shape: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(indices.into(), values.into(), dense_shape.into(), scope)
    }
    fn build_impl(
        &self,
        indices: crate::Output,
        values: crate::Output,
        dense_shape: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SparseTensorSliceDataset", |nd| {
            nd.add_input(indices);
            nd.add_input(values);
            nd.add_input(dense_shape);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.Tvalues {
                nd.set_attr_type("Tvalues", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SparseTensorSliceDataset' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        indices: crate::Output,
        values: crate::Output,
        dense_shape: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SparseTensorSliceDatasetInst> {
        let op = scope.new_operation("SparseTensorSliceDataset", |builder| {
            builder.add_input(indices);
            builder.add_input(values);
            builder.add_input(dense_shape);
            if let ::std::option::Option::Some(value) = &self.Tvalues {
                builder.set_attr_type("Tvalues", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SparseTensorSliceDatasetInst { op })
    }
}
impl SparseTensorSliceDatasetInst {
    /// Returns the 'handle' Output of this 'SparseTensorSliceDataset' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'indices' Input of this 'SparseTensorSliceDataset' operation.
    pub fn indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'values' Input of this 'SparseTensorSliceDataset' operation.
    pub fn values(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'dense_shape' Input of this 'SparseTensorSliceDataset' operation.
    pub fn dense_shape(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<SparseTensorSliceDatasetInst> for crate::Operation {
    fn from(inst: SparseTensorSliceDatasetInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SparseTensorSliceDataset::new().build(indices, values, dense_shape, scope)`.
pub fn sparse_tensor_slice_dataset<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    indices: O0,
    values: O1,
    dense_shape: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SparseTensorSliceDataset::new().build(indices, values, dense_shape, scope)
}

/// Builder for the `SparseTensorToCSRSparseMatrix` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SparseTensorToCSRSparseMatrix {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SparseTensorToCSRSparseMatrix' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SparseTensorToCSRSparseMatrixInst {
    /// An instance of a fully built SparseTensorToCSRSparseMatrix Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SparseTensorToCSRSparseMatrix {
    /// Creates a new `SparseTensorToCSRSparseMatrix`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SparseTensorToCSRSparseMatrix` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        indices: O0,
        values: O1,
        dense_shape: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(indices.into(), values.into(), dense_shape.into(), scope)
    }
    fn build_impl(
        &self,
        indices: crate::Output,
        values: crate::Output,
        dense_shape: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SparseTensorToCSRSparseMatrix", |nd| {
            nd.add_input(indices);
            nd.add_input(values);
            nd.add_input(dense_shape);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SparseTensorToCSRSparseMatrix' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        indices: crate::Output,
        values: crate::Output,
        dense_shape: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SparseTensorToCSRSparseMatrixInst> {
        let op = scope.new_operation("SparseTensorToCSRSparseMatrix", |builder| {
            builder.add_input(indices);
            builder.add_input(values);
            builder.add_input(dense_shape);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SparseTensorToCSRSparseMatrixInst { op })
    }
}
impl SparseTensorToCSRSparseMatrixInst {
    /// Returns the 'sparse_matrix' Output of this 'SparseTensorToCSRSparseMatrix' operation.
    pub fn sparse_matrix(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'indices' Input of this 'SparseTensorToCSRSparseMatrix' operation.
    pub fn indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'values' Input of this 'SparseTensorToCSRSparseMatrix' operation.
    pub fn values(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'dense_shape' Input of this 'SparseTensorToCSRSparseMatrix' operation.
    pub fn dense_shape(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<SparseTensorToCSRSparseMatrixInst> for crate::Operation {
    fn from(inst: SparseTensorToCSRSparseMatrixInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SparseTensorToCSRSparseMatrix::new().build(indices, values, dense_shape, scope)`.
pub fn sparse_tensor_to_csrsparse_matrix<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    indices: O0,
    values: O1,
    dense_shape: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SparseTensorToCSRSparseMatrix::new().build(indices, values, dense_shape, scope)
}

/// Builder for the `SparseToDense` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SparseToDense {
    validate_indices: ::std::option::Option<bool>,
    T: ::std::option::Option<crate::DataType>,
    Tindices: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SparseToDense' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SparseToDenseInst {
    /// An instance of a fully built SparseToDense Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SparseToDense {
    /// Creates a new `SparseToDense`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `validate_indices` attribute.
    pub fn validate_indices<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.validate_indices = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tindices` attribute.
    pub fn Tindices<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tindices = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SparseToDense` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
    >(
        &self,
        sparse_indices: O0,
        output_shape: O1,
        sparse_values: O2,
        default_value: O3,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            sparse_indices.into(),
            output_shape.into(),
            sparse_values.into(),
            default_value.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        sparse_indices: crate::Output,
        output_shape: crate::Output,
        sparse_values: crate::Output,
        default_value: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SparseToDense", |nd| {
            nd.add_input(sparse_indices);
            nd.add_input(output_shape);
            nd.add_input(sparse_values);
            nd.add_input(default_value);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.validate_indices {
                nd.set_attr_bool("validate_indices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                nd.set_attr_type("Tindices", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SparseToDense' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        sparse_indices: crate::Output,
        output_shape: crate::Output,
        sparse_values: crate::Output,
        default_value: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SparseToDenseInst> {
        let op = scope.new_operation("SparseToDense", |builder| {
            builder.add_input(sparse_indices);
            builder.add_input(output_shape);
            builder.add_input(sparse_values);
            builder.add_input(default_value);
            if let ::std::option::Option::Some(value) = &self.validate_indices {
                builder.set_attr_bool("validate_indices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                builder.set_attr_type("Tindices", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SparseToDenseInst { op })
    }
}
impl SparseToDenseInst {
    /// Returns the 'dense' Output of this 'SparseToDense' operation.
    pub fn dense(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'sparse_indices' Input of this 'SparseToDense' operation.
    pub fn sparse_indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'output_shape' Input of this 'SparseToDense' operation.
    pub fn output_shape(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'sparse_values' Input of this 'SparseToDense' operation.
    pub fn sparse_values(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'default_value' Input of this 'SparseToDense' operation.
    pub fn default_value(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
}
impl From<SparseToDenseInst> for crate::Operation {
    fn from(inst: SparseToDenseInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SparseToDense::new().build(sparse_indices, output_shape, sparse_values, default_value, scope)`.
pub fn sparse_to_dense<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
>(
    sparse_indices: O0,
    output_shape: O1,
    sparse_values: O2,
    default_value: O3,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SparseToDense::new().build(
        sparse_indices,
        output_shape,
        sparse_values,
        default_value,
        scope,
    )
}

/// Builder for the `SparseToSparseSetOperation` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SparseToSparseSetOperation {
    set_operation: ::std::option::Option<::std::string::String>,
    validate_indices: ::std::option::Option<bool>,
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SparseToSparseSetOperation' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SparseToSparseSetOperationInst {
    /// An instance of a fully built SparseToSparseSetOperation Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SparseToSparseSetOperation {
    /// Creates a new `SparseToSparseSetOperation`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `set_operation` attribute.
    pub fn set_operation<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.set_operation = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `validate_indices` attribute.
    pub fn validate_indices<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.validate_indices = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SparseToSparseSetOperation` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
    >(
        &self,
        set1_indices: O0,
        set1_values: O1,
        set1_shape: O2,
        set2_indices: O3,
        set2_values: O4,
        set2_shape: O5,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            set1_indices.into(),
            set1_values.into(),
            set1_shape.into(),
            set2_indices.into(),
            set2_values.into(),
            set2_shape.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        set1_indices: crate::Output,
        set1_values: crate::Output,
        set1_shape: crate::Output,
        set2_indices: crate::Output,
        set2_values: crate::Output,
        set2_shape: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SparseToSparseSetOperation", |nd| {
            nd.add_input(set1_indices);
            nd.add_input(set1_values);
            nd.add_input(set1_shape);
            nd.add_input(set2_indices);
            nd.add_input(set2_values);
            nd.add_input(set2_shape);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.set_operation {
                nd.set_attr_string("set_operation", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.validate_indices {
                nd.set_attr_bool("validate_indices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SparseToSparseSetOperation' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        set1_indices: crate::Output,
        set1_values: crate::Output,
        set1_shape: crate::Output,
        set2_indices: crate::Output,
        set2_values: crate::Output,
        set2_shape: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SparseToSparseSetOperationInst> {
        let op = scope.new_operation("SparseToSparseSetOperation", |builder| {
            builder.add_input(set1_indices);
            builder.add_input(set1_values);
            builder.add_input(set1_shape);
            builder.add_input(set2_indices);
            builder.add_input(set2_values);
            builder.add_input(set2_shape);
            if let ::std::option::Option::Some(value) = &self.set_operation {
                builder.set_attr_string("set_operation", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.validate_indices {
                builder.set_attr_bool("validate_indices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SparseToSparseSetOperationInst { op })
    }
}
impl SparseToSparseSetOperationInst {
    /// Returns the 'result_indices' Output of this 'SparseToSparseSetOperation' operation.
    pub fn result_indices(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'result_values' Output of this 'SparseToSparseSetOperation' operation.
    pub fn result_values(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'result_shape' Output of this 'SparseToSparseSetOperation' operation.
    pub fn result_shape(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns the 'set1_indices' Input of this 'SparseToSparseSetOperation' operation.
    pub fn set1_indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'set1_values' Input of this 'SparseToSparseSetOperation' operation.
    pub fn set1_values(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'set1_shape' Input of this 'SparseToSparseSetOperation' operation.
    pub fn set1_shape(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'set2_indices' Input of this 'SparseToSparseSetOperation' operation.
    pub fn set2_indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'set2_values' Input of this 'SparseToSparseSetOperation' operation.
    pub fn set2_values(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
    /// Returns the 'set2_shape' Input of this 'SparseToSparseSetOperation' operation.
    pub fn set2_shape(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 5,
        }
    }
}
impl From<SparseToSparseSetOperationInst> for crate::Operation {
    fn from(inst: SparseToSparseSetOperationInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SparseToSparseSetOperation::new().build(set1_indices, set1_values, set1_shape, set2_indices, set2_values, set2_shape, scope)`.
pub fn sparse_to_sparse_set_operation<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
>(
    set1_indices: O0,
    set1_values: O1,
    set1_shape: O2,
    set2_indices: O3,
    set2_values: O4,
    set2_shape: O5,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SparseToSparseSetOperation::new().build(
        set1_indices,
        set1_values,
        set1_shape,
        set2_indices,
        set2_values,
        set2_shape,
        scope,
    )
}

/// Builder for the `Spence` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Spence {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Spence' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SpenceInst {
    /// An instance of a fully built Spence Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Spence {
    /// Creates a new `Spence`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Spence` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        x: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Spence", |nd| {
            nd.add_input(x);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Spence' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SpenceInst> {
        let op = scope.new_operation("Spence", |builder| {
            builder.add_input(x);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SpenceInst { op })
    }
}
impl SpenceInst {
    /// Returns the 'y' Output of this 'Spence' operation.
    pub fn y(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'Spence' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<SpenceInst> for crate::Operation {
    fn from(inst: SpenceInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Spence::new().build(x, scope)`.
pub fn spence<O0: ::std::convert::Into<crate::Output>>(
    x: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Spence::new().build(x, scope)
}

/// Builder for the `Split` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Split {
    num_split: ::std::option::Option<i64>,
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Split' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SplitInst {
    /// An instance of a fully built Split Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Split {
    /// Creates a new `Split`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `num_split` attribute.
    pub fn num_split<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.num_split = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Split` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        split_dim: O0,
        value: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(split_dim.into(), value.into(), scope)
    }
    fn build_impl(
        &self,
        split_dim: crate::Output,
        value: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Split", |nd| {
            nd.add_input(split_dim);
            nd.add_input(value);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.num_split {
                nd.set_attr_int("num_split", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Split' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        split_dim: crate::Output,
        value: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SplitInst> {
        let op = scope.new_operation("Split", |builder| {
            builder.add_input(split_dim);
            builder.add_input(value);
            if let ::std::option::Option::Some(value) = &self.num_split {
                builder.set_attr_int("num_split", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SplitInst { op })
    }
}
impl SplitInst {
    /// Returns a Vector of output for 'output' Output of this Split operation.
    pub fn output(&self) -> crate::Result<Vec<crate::Output>> {
        let mut Outputs = vec![];
        for i in 0..self.op.get_attr_int("num_split")? as i32 {
            Outputs.push(crate::Output {
                operation: self.op.clone(),
                index: i,
            });
        }
        Ok(Outputs)
    }
    /// Returns the 'split_dim' Input of this 'Split' operation.
    pub fn split_dim(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'value' Input of this 'Split' operation.
    pub fn value(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<SplitInst> for crate::Operation {
    fn from(inst: SplitInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Split::new().build(split_dim, value, scope)`.
pub fn split<O0: ::std::convert::Into<crate::Output>, O1: ::std::convert::Into<crate::Output>>(
    split_dim: O0,
    value: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Split::new().build(split_dim, value, scope)
}

/// Builder for the `SplitDedupData` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SplitDedupData {
    integer_type: ::std::option::Option<crate::DataType>,
    float_type: ::std::option::Option<crate::DataType>,
    tuple_mask: ::std::option::Option<::std::string::String>,
    config: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SplitDedupData' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SplitDedupDataInst {
    /// An instance of a fully built SplitDedupData Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SplitDedupData {
    /// Creates a new `SplitDedupData`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `integer_type` attribute.
    pub fn integer_type<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.integer_type = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `float_type` attribute.
    pub fn float_type<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.float_type = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `tuple_mask` attribute.
    pub fn tuple_mask<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.tuple_mask = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `config` attribute.
    pub fn config<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.config = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SplitDedupData` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SplitDedupData", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.integer_type {
                nd.set_attr_type("integer_type", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.float_type {
                nd.set_attr_type("float_type", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.tuple_mask {
                nd.set_attr_string("tuple_mask", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.config {
                nd.set_attr_string("config", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SplitDedupData' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SplitDedupDataInst> {
        let op = scope.new_operation("SplitDedupData", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.integer_type {
                builder.set_attr_type("integer_type", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.float_type {
                builder.set_attr_type("float_type", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.tuple_mask {
                builder.set_attr_string("tuple_mask", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.config {
                builder.set_attr_string("config", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SplitDedupDataInst { op })
    }
}
impl SplitDedupDataInst {
    /// Returns the 'integer_tensor' Output of this 'SplitDedupData' operation.
    pub fn integer_tensor(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'float_tensor' Output of this 'SplitDedupData' operation.
    pub fn float_tensor(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'input' Input of this 'SplitDedupData' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<SplitDedupDataInst> for crate::Operation {
    fn from(inst: SplitDedupDataInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SplitDedupData::new().build(input, scope)`.
pub fn split_dedup_data<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SplitDedupData::new().build(input, scope)
}

/// Builder for the `SplitV` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SplitV {
    num_split: ::std::option::Option<i64>,
    T: ::std::option::Option<crate::DataType>,
    Tlen: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SplitV' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SplitVInst {
    /// An instance of a fully built SplitV Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SplitV {
    /// Creates a new `SplitV`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `num_split` attribute.
    pub fn num_split<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.num_split = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tlen` attribute.
    pub fn Tlen<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Tlen = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SplitV` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        value: O0,
        size_splits: O1,
        split_dim: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(value.into(), size_splits.into(), split_dim.into(), scope)
    }
    fn build_impl(
        &self,
        value: crate::Output,
        size_splits: crate::Output,
        split_dim: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SplitV", |nd| {
            nd.add_input(value);
            nd.add_input(size_splits);
            nd.add_input(split_dim);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.num_split {
                nd.set_attr_int("num_split", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tlen {
                nd.set_attr_type("Tlen", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SplitV' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        value: crate::Output,
        size_splits: crate::Output,
        split_dim: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SplitVInst> {
        let op = scope.new_operation("SplitV", |builder| {
            builder.add_input(value);
            builder.add_input(size_splits);
            builder.add_input(split_dim);
            if let ::std::option::Option::Some(value) = &self.num_split {
                builder.set_attr_int("num_split", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tlen {
                builder.set_attr_type("Tlen", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SplitVInst { op })
    }
}
impl SplitVInst {
    /// Returns a Vector of output for 'output' Output of this SplitV operation.
    pub fn output(&self) -> crate::Result<Vec<crate::Output>> {
        let mut Outputs = vec![];
        for i in 0..self.op.get_attr_int("num_split")? as i32 {
            Outputs.push(crate::Output {
                operation: self.op.clone(),
                index: i,
            });
        }
        Ok(Outputs)
    }
    /// Returns the 'value' Input of this 'SplitV' operation.
    pub fn value(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'size_splits' Input of this 'SplitV' operation.
    pub fn size_splits(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'split_dim' Input of this 'SplitV' operation.
    pub fn split_dim(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<SplitVInst> for crate::Operation {
    fn from(inst: SplitVInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SplitV::new().build(value, size_splits, split_dim, scope)`.
pub fn split_v<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    value: O0,
    size_splits: O1,
    split_dim: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SplitV::new().build(value, size_splits, split_dim, scope)
}

/// Builder for the `SqlDataset` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SqlDataset {
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SqlDataset' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SqlDatasetInst {
    /// An instance of a fully built SqlDataset Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SqlDataset {
    /// Creates a new `SqlDataset`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SqlDataset` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        driver_name: O0,
        data_source_name: O1,
        query: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            driver_name.into(),
            data_source_name.into(),
            query.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        driver_name: crate::Output,
        data_source_name: crate::Output,
        query: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SqlDataset", |nd| {
            nd.add_input(driver_name);
            nd.add_input(data_source_name);
            nd.add_input(query);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SqlDataset' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        driver_name: crate::Output,
        data_source_name: crate::Output,
        query: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SqlDatasetInst> {
        let op = scope.new_operation("SqlDataset", |builder| {
            builder.add_input(driver_name);
            builder.add_input(data_source_name);
            builder.add_input(query);
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SqlDatasetInst { op })
    }
}
impl SqlDatasetInst {
    /// Returns the 'handle' Output of this 'SqlDataset' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'driver_name' Input of this 'SqlDataset' operation.
    pub fn driver_name(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'data_source_name' Input of this 'SqlDataset' operation.
    pub fn data_source_name(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'query' Input of this 'SqlDataset' operation.
    pub fn query(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<SqlDatasetInst> for crate::Operation {
    fn from(inst: SqlDatasetInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SqlDataset::new().build(driver_name, data_source_name, query, scope)`.
pub fn sql_dataset<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    driver_name: O0,
    data_source_name: O1,
    query: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SqlDataset::new().build(driver_name, data_source_name, query, scope)
}

/// Builder for the `Sqrt` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Sqrt {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Sqrt' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SqrtInst {
    /// An instance of a fully built Sqrt Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Sqrt {
    /// Creates a new `Sqrt`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Sqrt` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        x: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Sqrt", |nd| {
            nd.add_input(x);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Sqrt' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SqrtInst> {
        let op = scope.new_operation("Sqrt", |builder| {
            builder.add_input(x);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SqrtInst { op })
    }
}
impl SqrtInst {
    /// Returns the 'y' Output of this 'Sqrt' operation.
    pub fn y(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'Sqrt' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<SqrtInst> for crate::Operation {
    fn from(inst: SqrtInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Sqrt::new().build(x, scope)`.
pub fn sqrt<O0: ::std::convert::Into<crate::Output>>(
    x: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Sqrt::new().build(x, scope)
}

/// Builder for the `SqrtGrad` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SqrtGrad {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SqrtGrad' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SqrtGradInst {
    /// An instance of a fully built SqrtGrad Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SqrtGrad {
    /// Creates a new `SqrtGrad`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SqrtGrad` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        y: O0,
        dy: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(y.into(), dy.into(), scope)
    }
    fn build_impl(
        &self,
        y: crate::Output,
        dy: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SqrtGrad", |nd| {
            nd.add_input(y);
            nd.add_input(dy);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SqrtGrad' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        y: crate::Output,
        dy: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SqrtGradInst> {
        let op = scope.new_operation("SqrtGrad", |builder| {
            builder.add_input(y);
            builder.add_input(dy);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SqrtGradInst { op })
    }
}
impl SqrtGradInst {
    /// Returns the 'z' Output of this 'SqrtGrad' operation.
    pub fn z(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'y' Input of this 'SqrtGrad' operation.
    pub fn y(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'dy' Input of this 'SqrtGrad' operation.
    pub fn dy(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<SqrtGradInst> for crate::Operation {
    fn from(inst: SqrtGradInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SqrtGrad::new().build(y, dy, scope)`.
pub fn sqrt_grad<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    y: O0,
    dy: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SqrtGrad::new().build(y, dy, scope)
}

/// Builder for the `Square` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Square {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Square' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SquareInst {
    /// An instance of a fully built Square Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Square {
    /// Creates a new `Square`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Square` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        x: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Square", |nd| {
            nd.add_input(x);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Square' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SquareInst> {
        let op = scope.new_operation("Square", |builder| {
            builder.add_input(x);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SquareInst { op })
    }
}
impl SquareInst {
    /// Returns the 'y' Output of this 'Square' operation.
    pub fn y(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'Square' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<SquareInst> for crate::Operation {
    fn from(inst: SquareInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Square::new().build(x, scope)`.
pub fn square<O0: ::std::convert::Into<crate::Output>>(
    x: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Square::new().build(x, scope)
}

/// Builder for the `SquaredDifference` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SquaredDifference {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SquaredDifference' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SquaredDifferenceInst {
    /// An instance of a fully built SquaredDifference Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SquaredDifference {
    /// Creates a new `SquaredDifference`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SquaredDifference` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        x: O0,
        y: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), y.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        y: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SquaredDifference", |nd| {
            nd.add_input(x);
            nd.add_input(y);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SquaredDifference' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        y: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SquaredDifferenceInst> {
        let op = scope.new_operation("SquaredDifference", |builder| {
            builder.add_input(x);
            builder.add_input(y);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SquaredDifferenceInst { op })
    }
}
impl SquaredDifferenceInst {
    /// Returns the 'z' Output of this 'SquaredDifference' operation.
    pub fn z(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'SquaredDifference' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'y' Input of this 'SquaredDifference' operation.
    pub fn y(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<SquaredDifferenceInst> for crate::Operation {
    fn from(inst: SquaredDifferenceInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SquaredDifference::new().build(x, y, scope)`.
pub fn squared_difference<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    x: O0,
    y: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SquaredDifference::new().build(x, y, scope)
}

/// Builder for the `Squeeze` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Squeeze {
    T: ::std::option::Option<crate::DataType>,
    squeeze_dims: ::std::option::Option<::std::vec::Vec<i64>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Squeeze' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SqueezeInst {
    /// An instance of a fully built Squeeze Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Squeeze {
    /// Creates a new `Squeeze`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `squeeze_dims` attribute.
    pub fn squeeze_dims<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.squeeze_dims = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Squeeze` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Squeeze", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.squeeze_dims {
                nd.set_attr_int_list("squeeze_dims", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Squeeze' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SqueezeInst> {
        let op = scope.new_operation("Squeeze", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.squeeze_dims {
                builder.set_attr_int_list("squeeze_dims", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SqueezeInst { op })
    }
}
impl SqueezeInst {
    /// Returns the 'output' Output of this 'Squeeze' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'Squeeze' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<SqueezeInst> for crate::Operation {
    fn from(inst: SqueezeInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Squeeze::new().build(input, scope)`.
pub fn squeeze<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Squeeze::new().build(input, scope)
}

/// Builder for the `Stack` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Stack {
    elem_type: ::std::option::Option<crate::DataType>,
    stack_name: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Stack' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct StackInst {
    /// An instance of a fully built Stack Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Stack {
    /// Creates a new `Stack`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `elem_type` attribute.
    pub fn elem_type<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.elem_type = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `stack_name` attribute.
    pub fn stack_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.stack_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Stack` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("Stack", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.elem_type {
                nd.set_attr_type("elem_type", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.stack_name {
                nd.set_attr_string("stack_name", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Stack' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(&self, scope: &mut crate::Scope) -> crate::Result<StackInst> {
        let op = scope.new_operation("Stack", |builder| {
            if let ::std::option::Option::Some(value) = &self.elem_type {
                builder.set_attr_type("elem_type", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.stack_name {
                builder.set_attr_string("stack_name", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(StackInst { op })
    }
}
impl StackInst {
    /// Returns the 'handle' Output of this 'Stack' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
}
impl From<StackInst> for crate::Operation {
    fn from(inst: StackInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Stack::new().build(scope)`.
pub fn stack(scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
    Stack::new().build(scope)
}

/// Builder for the `StackClose` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct StackClose {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'StackClose' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct StackCloseInst {
    /// An instance of a fully built StackClose Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl StackClose {
    /// Creates a new `StackClose`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `StackClose` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        handle: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(handle.into(), scope)
    }
    fn build_impl(
        &self,
        handle: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("StackClose", |nd| {
            nd.add_input(handle);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'StackClose' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        handle: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<StackCloseInst> {
        let op = scope.new_operation("StackClose", |builder| {
            builder.add_input(handle);
            ::std::result::Result::Ok(())
        })?;
        Ok(StackCloseInst { op })
    }
}
impl StackCloseInst {
    /// Returns the 'handle' Input of this 'StackClose' operation.
    pub fn handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<StackCloseInst> for crate::Operation {
    fn from(inst: StackCloseInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `StackClose::new().build(handle, scope)`.
pub fn stack_close<O0: ::std::convert::Into<crate::Output>>(
    handle: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    StackClose::new().build(handle, scope)
}

/// Builder for the `StackCloseV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct StackCloseV2 {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'StackCloseV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct StackCloseV2Inst {
    /// An instance of a fully built StackCloseV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl StackCloseV2 {
    /// Creates a new `StackCloseV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `StackCloseV2` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        handle: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(handle.into(), scope)
    }
    fn build_impl(
        &self,
        handle: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("StackCloseV2", |nd| {
            nd.add_input(handle);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'StackCloseV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        handle: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<StackCloseV2Inst> {
        let op = scope.new_operation("StackCloseV2", |builder| {
            builder.add_input(handle);
            ::std::result::Result::Ok(())
        })?;
        Ok(StackCloseV2Inst { op })
    }
}
impl StackCloseV2Inst {
    /// Returns the 'handle' Input of this 'StackCloseV2' operation.
    pub fn handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<StackCloseV2Inst> for crate::Operation {
    fn from(inst: StackCloseV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `StackCloseV2::new().build(handle, scope)`.
pub fn stack_close_v2<O0: ::std::convert::Into<crate::Output>>(
    handle: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    StackCloseV2::new().build(handle, scope)
}

/// Builder for the `StackPop` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct StackPop {
    elem_type: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'StackPop' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct StackPopInst {
    /// An instance of a fully built StackPop Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl StackPop {
    /// Creates a new `StackPop`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `elem_type` attribute.
    pub fn elem_type<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.elem_type = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `StackPop` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        handle: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(handle.into(), scope)
    }
    fn build_impl(
        &self,
        handle: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("StackPop", |nd| {
            nd.add_input(handle);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.elem_type {
                nd.set_attr_type("elem_type", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'StackPop' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        handle: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<StackPopInst> {
        let op = scope.new_operation("StackPop", |builder| {
            builder.add_input(handle);
            if let ::std::option::Option::Some(value) = &self.elem_type {
                builder.set_attr_type("elem_type", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(StackPopInst { op })
    }
}
impl StackPopInst {
    /// Returns the 'elem' Output of this 'StackPop' operation.
    pub fn elem(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'handle' Input of this 'StackPop' operation.
    pub fn handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<StackPopInst> for crate::Operation {
    fn from(inst: StackPopInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `StackPop::new().build(handle, scope)`.
pub fn stack_pop<O0: ::std::convert::Into<crate::Output>>(
    handle: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    StackPop::new().build(handle, scope)
}

/// Builder for the `StackPopV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct StackPopV2 {
    elem_type: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'StackPopV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct StackPopV2Inst {
    /// An instance of a fully built StackPopV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl StackPopV2 {
    /// Creates a new `StackPopV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `elem_type` attribute.
    pub fn elem_type<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.elem_type = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `StackPopV2` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        handle: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(handle.into(), scope)
    }
    fn build_impl(
        &self,
        handle: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("StackPopV2", |nd| {
            nd.add_input(handle);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.elem_type {
                nd.set_attr_type("elem_type", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'StackPopV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        handle: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<StackPopV2Inst> {
        let op = scope.new_operation("StackPopV2", |builder| {
            builder.add_input(handle);
            if let ::std::option::Option::Some(value) = &self.elem_type {
                builder.set_attr_type("elem_type", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(StackPopV2Inst { op })
    }
}
impl StackPopV2Inst {
    /// Returns the 'elem' Output of this 'StackPopV2' operation.
    pub fn elem(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'handle' Input of this 'StackPopV2' operation.
    pub fn handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<StackPopV2Inst> for crate::Operation {
    fn from(inst: StackPopV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `StackPopV2::new().build(handle, scope)`.
pub fn stack_pop_v2<O0: ::std::convert::Into<crate::Output>>(
    handle: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    StackPopV2::new().build(handle, scope)
}

/// Builder for the `StackPush` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct StackPush {
    T: ::std::option::Option<crate::DataType>,
    swap_memory: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'StackPush' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct StackPushInst {
    /// An instance of a fully built StackPush Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl StackPush {
    /// Creates a new `StackPush`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `swap_memory` attribute.
    pub fn swap_memory<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.swap_memory = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `StackPush` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        handle: O0,
        elem: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(handle.into(), elem.into(), scope)
    }
    fn build_impl(
        &self,
        handle: crate::Output,
        elem: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("StackPush", |nd| {
            nd.add_input(handle);
            nd.add_input(elem);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.swap_memory {
                nd.set_attr_bool("swap_memory", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'StackPush' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        handle: crate::Output,
        elem: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<StackPushInst> {
        let op = scope.new_operation("StackPush", |builder| {
            builder.add_input(handle);
            builder.add_input(elem);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.swap_memory {
                builder.set_attr_bool("swap_memory", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(StackPushInst { op })
    }
}
impl StackPushInst {
    /// Returns the 'output' Output of this 'StackPush' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'handle' Input of this 'StackPush' operation.
    pub fn handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'elem' Input of this 'StackPush' operation.
    pub fn elem(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<StackPushInst> for crate::Operation {
    fn from(inst: StackPushInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `StackPush::new().build(handle, elem, scope)`.
pub fn stack_push<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    handle: O0,
    elem: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    StackPush::new().build(handle, elem, scope)
}

/// Builder for the `StackPushV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct StackPushV2 {
    T: ::std::option::Option<crate::DataType>,
    swap_memory: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'StackPushV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct StackPushV2Inst {
    /// An instance of a fully built StackPushV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl StackPushV2 {
    /// Creates a new `StackPushV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `swap_memory` attribute.
    pub fn swap_memory<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.swap_memory = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `StackPushV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        handle: O0,
        elem: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(handle.into(), elem.into(), scope)
    }
    fn build_impl(
        &self,
        handle: crate::Output,
        elem: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("StackPushV2", |nd| {
            nd.add_input(handle);
            nd.add_input(elem);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.swap_memory {
                nd.set_attr_bool("swap_memory", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'StackPushV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        handle: crate::Output,
        elem: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<StackPushV2Inst> {
        let op = scope.new_operation("StackPushV2", |builder| {
            builder.add_input(handle);
            builder.add_input(elem);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.swap_memory {
                builder.set_attr_bool("swap_memory", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(StackPushV2Inst { op })
    }
}
impl StackPushV2Inst {
    /// Returns the 'output' Output of this 'StackPushV2' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'handle' Input of this 'StackPushV2' operation.
    pub fn handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'elem' Input of this 'StackPushV2' operation.
    pub fn elem(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<StackPushV2Inst> for crate::Operation {
    fn from(inst: StackPushV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `StackPushV2::new().build(handle, elem, scope)`.
pub fn stack_push_v2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    handle: O0,
    elem: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    StackPushV2::new().build(handle, elem, scope)
}

/// Builder for the `StackV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct StackV2 {
    elem_type: ::std::option::Option<crate::DataType>,
    stack_name: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'StackV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct StackV2Inst {
    /// An instance of a fully built StackV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl StackV2 {
    /// Creates a new `StackV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `elem_type` attribute.
    pub fn elem_type<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.elem_type = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `stack_name` attribute.
    pub fn stack_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.stack_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `StackV2` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        max_size: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(max_size.into(), scope)
    }
    fn build_impl(
        &self,
        max_size: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("StackV2", |nd| {
            nd.add_input(max_size);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.elem_type {
                nd.set_attr_type("elem_type", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.stack_name {
                nd.set_attr_string("stack_name", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'StackV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        max_size: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<StackV2Inst> {
        let op = scope.new_operation("StackV2", |builder| {
            builder.add_input(max_size);
            if let ::std::option::Option::Some(value) = &self.elem_type {
                builder.set_attr_type("elem_type", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.stack_name {
                builder.set_attr_string("stack_name", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(StackV2Inst { op })
    }
}
impl StackV2Inst {
    /// Returns the 'handle' Output of this 'StackV2' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'max_size' Input of this 'StackV2' operation.
    pub fn max_size(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<StackV2Inst> for crate::Operation {
    fn from(inst: StackV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `StackV2::new().build(max_size, scope)`.
pub fn stack_v2<O0: ::std::convert::Into<crate::Output>>(
    max_size: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    StackV2::new().build(max_size, scope)
}

/// Builder for the `Stage` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Stage {
    capacity: ::std::option::Option<i64>,
    memory_limit: ::std::option::Option<i64>,
    dtypes: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    container: ::std::option::Option<::std::string::String>,
    shared_name: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Stage' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct StageInst {
    /// An instance of a fully built Stage Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Stage {
    /// Creates a new `Stage`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `capacity` attribute.
    pub fn capacity<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.capacity = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `memory_limit` attribute.
    pub fn memory_limit<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.memory_limit = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `dtypes` attribute.
    pub fn dtypes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.dtypes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `container` attribute.
    pub fn container<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.container = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shared_name` attribute.
    pub fn shared_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.shared_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Stage` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        values: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(values.into(), scope)
    }
    fn build_impl(
        &self,
        values: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Stage", |nd| {
            nd.add_input(values);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.capacity {
                nd.set_attr_int("capacity", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.memory_limit {
                nd.set_attr_int("memory_limit", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dtypes {
                nd.set_attr_type_list("dtypes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.container {
                nd.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                nd.set_attr_string("shared_name", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Stage' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        values: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<StageInst> {
        let op = scope.new_operation("Stage", |builder| {
            builder.add_input(values);
            if let ::std::option::Option::Some(value) = &self.capacity {
                builder.set_attr_int("capacity", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.memory_limit {
                builder.set_attr_int("memory_limit", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dtypes {
                builder.set_attr_type_list("dtypes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.container {
                builder.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                builder.set_attr_string("shared_name", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(StageInst { op })
    }
}
impl StageInst {
    /// Returns the 'values' Input of this 'Stage' operation.
    pub fn values(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<StageInst> for crate::Operation {
    fn from(inst: StageInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Stage::new().build(values, scope)`.
pub fn stage<O0: ::std::convert::Into<crate::Output>>(
    values: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Stage::new().build(values, scope)
}

/// Builder for the `StageClear` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct StageClear {
    capacity: ::std::option::Option<i64>,
    memory_limit: ::std::option::Option<i64>,
    dtypes: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    container: ::std::option::Option<::std::string::String>,
    shared_name: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'StageClear' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct StageClearInst {
    /// An instance of a fully built StageClear Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl StageClear {
    /// Creates a new `StageClear`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `capacity` attribute.
    pub fn capacity<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.capacity = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `memory_limit` attribute.
    pub fn memory_limit<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.memory_limit = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `dtypes` attribute.
    pub fn dtypes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.dtypes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `container` attribute.
    pub fn container<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.container = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shared_name` attribute.
    pub fn shared_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.shared_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `StageClear` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("StageClear", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.capacity {
                nd.set_attr_int("capacity", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.memory_limit {
                nd.set_attr_int("memory_limit", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dtypes {
                nd.set_attr_type_list("dtypes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.container {
                nd.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                nd.set_attr_string("shared_name", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'StageClear' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(&self, scope: &mut crate::Scope) -> crate::Result<StageClearInst> {
        let op = scope.new_operation("StageClear", |builder| {
            if let ::std::option::Option::Some(value) = &self.capacity {
                builder.set_attr_int("capacity", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.memory_limit {
                builder.set_attr_int("memory_limit", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dtypes {
                builder.set_attr_type_list("dtypes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.container {
                builder.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                builder.set_attr_string("shared_name", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(StageClearInst { op })
    }
}
impl StageClearInst {}
impl From<StageClearInst> for crate::Operation {
    fn from(inst: StageClearInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `StageClear::new().build(scope)`.
pub fn stage_clear(scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
    StageClear::new().build(scope)
}

/// Builder for the `StagePeek` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct StagePeek {
    capacity: ::std::option::Option<i64>,
    memory_limit: ::std::option::Option<i64>,
    dtypes: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    container: ::std::option::Option<::std::string::String>,
    shared_name: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'StagePeek' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct StagePeekInst {
    /// An instance of a fully built StagePeek Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl StagePeek {
    /// Creates a new `StagePeek`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `capacity` attribute.
    pub fn capacity<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.capacity = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `memory_limit` attribute.
    pub fn memory_limit<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.memory_limit = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `dtypes` attribute.
    pub fn dtypes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.dtypes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `container` attribute.
    pub fn container<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.container = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shared_name` attribute.
    pub fn shared_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.shared_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `StagePeek` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        index: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(index.into(), scope)
    }
    fn build_impl(
        &self,
        index: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("StagePeek", |nd| {
            nd.add_input(index);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.capacity {
                nd.set_attr_int("capacity", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.memory_limit {
                nd.set_attr_int("memory_limit", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dtypes {
                nd.set_attr_type_list("dtypes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.container {
                nd.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                nd.set_attr_string("shared_name", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'StagePeek' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        index: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<StagePeekInst> {
        let op = scope.new_operation("StagePeek", |builder| {
            builder.add_input(index);
            if let ::std::option::Option::Some(value) = &self.capacity {
                builder.set_attr_int("capacity", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.memory_limit {
                builder.set_attr_int("memory_limit", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dtypes {
                builder.set_attr_type_list("dtypes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.container {
                builder.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                builder.set_attr_string("shared_name", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(StagePeekInst { op })
    }
}
impl StagePeekInst {
    /// Returns the 'values' Output of this 'StagePeek' operation.
    pub fn values(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'index' Input of this 'StagePeek' operation.
    pub fn index(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<StagePeekInst> for crate::Operation {
    fn from(inst: StagePeekInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `StagePeek::new().build(index, scope)`.
pub fn stage_peek<O0: ::std::convert::Into<crate::Output>>(
    index: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    StagePeek::new().build(index, scope)
}

/// Builder for the `StageSize` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct StageSize {
    capacity: ::std::option::Option<i64>,
    memory_limit: ::std::option::Option<i64>,
    dtypes: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    container: ::std::option::Option<::std::string::String>,
    shared_name: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'StageSize' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct StageSizeInst {
    /// An instance of a fully built StageSize Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl StageSize {
    /// Creates a new `StageSize`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `capacity` attribute.
    pub fn capacity<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.capacity = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `memory_limit` attribute.
    pub fn memory_limit<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.memory_limit = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `dtypes` attribute.
    pub fn dtypes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.dtypes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `container` attribute.
    pub fn container<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.container = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shared_name` attribute.
    pub fn shared_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.shared_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `StageSize` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("StageSize", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.capacity {
                nd.set_attr_int("capacity", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.memory_limit {
                nd.set_attr_int("memory_limit", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dtypes {
                nd.set_attr_type_list("dtypes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.container {
                nd.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                nd.set_attr_string("shared_name", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'StageSize' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(&self, scope: &mut crate::Scope) -> crate::Result<StageSizeInst> {
        let op = scope.new_operation("StageSize", |builder| {
            if let ::std::option::Option::Some(value) = &self.capacity {
                builder.set_attr_int("capacity", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.memory_limit {
                builder.set_attr_int("memory_limit", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dtypes {
                builder.set_attr_type_list("dtypes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.container {
                builder.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                builder.set_attr_string("shared_name", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(StageSizeInst { op })
    }
}
impl StageSizeInst {
    /// Returns the 'size' Output of this 'StageSize' operation.
    pub fn size(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
}
impl From<StageSizeInst> for crate::Operation {
    fn from(inst: StageSizeInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `StageSize::new().build(scope)`.
pub fn stage_size(scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
    StageSize::new().build(scope)
}

/// Builder for the `StatefulPartitionedCall` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct StatefulPartitionedCall {
    Tin: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    Tout: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    f: ::std::option::Option<::std::string::String>,
    config: ::std::option::Option<::std::string::String>,
    config_proto: ::std::option::Option<::std::string::String>,
    executor_type: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'StatefulPartitionedCall' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct StatefulPartitionedCallInst {
    /// An instance of a fully built StatefulPartitionedCall Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl StatefulPartitionedCall {
    /// Creates a new `StatefulPartitionedCall`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `Tin` attribute.
    pub fn Tin<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tin = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tout` attribute.
    pub fn Tout<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tout = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `f` attribute.
    pub fn f<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.f = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `config` attribute.
    pub fn config<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.config = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `config_proto` attribute.
    pub fn config_proto<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.config_proto = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `executor_type` attribute.
    pub fn executor_type<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.executor_type = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `StatefulPartitionedCall` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        args: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(args.into(), scope)
    }
    fn build_impl(
        &self,
        args: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("StatefulPartitionedCall", |nd| {
            nd.add_input(args);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.Tin {
                nd.set_attr_type_list("Tin", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tout {
                nd.set_attr_type_list("Tout", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.f {
                nd.set_attr_string("f", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.config {
                nd.set_attr_string("config", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.config_proto {
                nd.set_attr_string("config_proto", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.executor_type {
                nd.set_attr_string("executor_type", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'StatefulPartitionedCall' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        args: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<StatefulPartitionedCallInst> {
        let op = scope.new_operation("StatefulPartitionedCall", |builder| {
            builder.add_input(args);
            if let ::std::option::Option::Some(value) = &self.Tin {
                builder.set_attr_type_list("Tin", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tout {
                builder.set_attr_type_list("Tout", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.f {
                builder.set_attr_string("f", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.config {
                builder.set_attr_string("config", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.config_proto {
                builder.set_attr_string("config_proto", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.executor_type {
                builder.set_attr_string("executor_type", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(StatefulPartitionedCallInst { op })
    }
}
impl StatefulPartitionedCallInst {
    /// Returns the 'output' Output of this 'StatefulPartitionedCall' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'args' Input of this 'StatefulPartitionedCall' operation.
    pub fn args(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<StatefulPartitionedCallInst> for crate::Operation {
    fn from(inst: StatefulPartitionedCallInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `StatefulPartitionedCall::new().build(args, scope)`.
pub fn stateful_partitioned_call<O0: ::std::convert::Into<crate::Output>>(
    args: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    StatefulPartitionedCall::new().build(args, scope)
}

/// Builder for the `StatefulRandomBinomial` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct StatefulRandomBinomial {
    S: ::std::option::Option<crate::DataType>,
    T: ::std::option::Option<crate::DataType>,
    dtype: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'StatefulRandomBinomial' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct StatefulRandomBinomialInst {
    /// An instance of a fully built StatefulRandomBinomial Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl StatefulRandomBinomial {
    /// Creates a new `StatefulRandomBinomial`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `S` attribute.
    pub fn S<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.S = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `dtype` attribute.
    pub fn dtype<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `StatefulRandomBinomial` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
    >(
        &self,
        resource: O0,
        algorithm: O1,
        shape: O2,
        counts: O3,
        probs: O4,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            resource.into(),
            algorithm.into(),
            shape.into(),
            counts.into(),
            probs.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        resource: crate::Output,
        algorithm: crate::Output,
        shape: crate::Output,
        counts: crate::Output,
        probs: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("StatefulRandomBinomial", |nd| {
            nd.add_input(resource);
            nd.add_input(algorithm);
            nd.add_input(shape);
            nd.add_input(counts);
            nd.add_input(probs);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.S {
                nd.set_attr_type("S", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                nd.set_attr_type("dtype", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'StatefulRandomBinomial' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        resource: crate::Output,
        algorithm: crate::Output,
        shape: crate::Output,
        counts: crate::Output,
        probs: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<StatefulRandomBinomialInst> {
        let op = scope.new_operation("StatefulRandomBinomial", |builder| {
            builder.add_input(resource);
            builder.add_input(algorithm);
            builder.add_input(shape);
            builder.add_input(counts);
            builder.add_input(probs);
            if let ::std::option::Option::Some(value) = &self.S {
                builder.set_attr_type("S", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                builder.set_attr_type("dtype", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(StatefulRandomBinomialInst { op })
    }
}
impl StatefulRandomBinomialInst {
    /// Returns the 'output' Output of this 'StatefulRandomBinomial' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'resource' Input of this 'StatefulRandomBinomial' operation.
    pub fn resource(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'algorithm' Input of this 'StatefulRandomBinomial' operation.
    pub fn algorithm(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'shape' Input of this 'StatefulRandomBinomial' operation.
    pub fn shape(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'counts' Input of this 'StatefulRandomBinomial' operation.
    pub fn counts(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'probs' Input of this 'StatefulRandomBinomial' operation.
    pub fn probs(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
}
impl From<StatefulRandomBinomialInst> for crate::Operation {
    fn from(inst: StatefulRandomBinomialInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `StatefulRandomBinomial::new().build(resource, algorithm, shape, counts, probs, scope)`.
pub fn stateful_random_binomial<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
>(
    resource: O0,
    algorithm: O1,
    shape: O2,
    counts: O3,
    probs: O4,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    StatefulRandomBinomial::new().build(resource, algorithm, shape, counts, probs, scope)
}

/// Builder for the `StatefulStandardNormal` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct StatefulStandardNormal {
    dtype: ::std::option::Option<crate::DataType>,
    shape_dtype: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'StatefulStandardNormal' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct StatefulStandardNormalInst {
    /// An instance of a fully built StatefulStandardNormal Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl StatefulStandardNormal {
    /// Creates a new `StatefulStandardNormal`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `dtype` attribute.
    pub fn dtype<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shape_dtype` attribute.
    pub fn shape_dtype<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.shape_dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `StatefulStandardNormal` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        resource: O0,
        shape: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(resource.into(), shape.into(), scope)
    }
    fn build_impl(
        &self,
        resource: crate::Output,
        shape: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("StatefulStandardNormal", |nd| {
            nd.add_input(resource);
            nd.add_input(shape);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                nd.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shape_dtype {
                nd.set_attr_type("shape_dtype", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'StatefulStandardNormal' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        resource: crate::Output,
        shape: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<StatefulStandardNormalInst> {
        let op = scope.new_operation("StatefulStandardNormal", |builder| {
            builder.add_input(resource);
            builder.add_input(shape);
            if let ::std::option::Option::Some(value) = &self.dtype {
                builder.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shape_dtype {
                builder.set_attr_type("shape_dtype", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(StatefulStandardNormalInst { op })
    }
}
impl StatefulStandardNormalInst {
    /// Returns the 'output' Output of this 'StatefulStandardNormal' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'resource' Input of this 'StatefulStandardNormal' operation.
    pub fn resource(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'shape' Input of this 'StatefulStandardNormal' operation.
    pub fn shape(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<StatefulStandardNormalInst> for crate::Operation {
    fn from(inst: StatefulStandardNormalInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `StatefulStandardNormal::new().build(resource, shape, scope)`.
pub fn stateful_standard_normal<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    resource: O0,
    shape: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    StatefulStandardNormal::new().build(resource, shape, scope)
}

/// Builder for the `StatefulStandardNormalV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct StatefulStandardNormalV2 {
    dtype: ::std::option::Option<crate::DataType>,
    shape_dtype: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'StatefulStandardNormalV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct StatefulStandardNormalV2Inst {
    /// An instance of a fully built StatefulStandardNormalV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl StatefulStandardNormalV2 {
    /// Creates a new `StatefulStandardNormalV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `dtype` attribute.
    pub fn dtype<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shape_dtype` attribute.
    pub fn shape_dtype<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.shape_dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `StatefulStandardNormalV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        resource: O0,
        algorithm: O1,
        shape: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(resource.into(), algorithm.into(), shape.into(), scope)
    }
    fn build_impl(
        &self,
        resource: crate::Output,
        algorithm: crate::Output,
        shape: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("StatefulStandardNormalV2", |nd| {
            nd.add_input(resource);
            nd.add_input(algorithm);
            nd.add_input(shape);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                nd.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shape_dtype {
                nd.set_attr_type("shape_dtype", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'StatefulStandardNormalV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        resource: crate::Output,
        algorithm: crate::Output,
        shape: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<StatefulStandardNormalV2Inst> {
        let op = scope.new_operation("StatefulStandardNormalV2", |builder| {
            builder.add_input(resource);
            builder.add_input(algorithm);
            builder.add_input(shape);
            if let ::std::option::Option::Some(value) = &self.dtype {
                builder.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shape_dtype {
                builder.set_attr_type("shape_dtype", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(StatefulStandardNormalV2Inst { op })
    }
}
impl StatefulStandardNormalV2Inst {
    /// Returns the 'output' Output of this 'StatefulStandardNormalV2' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'resource' Input of this 'StatefulStandardNormalV2' operation.
    pub fn resource(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'algorithm' Input of this 'StatefulStandardNormalV2' operation.
    pub fn algorithm(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'shape' Input of this 'StatefulStandardNormalV2' operation.
    pub fn shape(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<StatefulStandardNormalV2Inst> for crate::Operation {
    fn from(inst: StatefulStandardNormalV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `StatefulStandardNormalV2::new().build(resource, algorithm, shape, scope)`.
pub fn stateful_standard_normal_v2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    resource: O0,
    algorithm: O1,
    shape: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    StatefulStandardNormalV2::new().build(resource, algorithm, shape, scope)
}

/// Builder for the `StatefulTruncatedNormal` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct StatefulTruncatedNormal {
    dtype: ::std::option::Option<crate::DataType>,
    shape_dtype: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'StatefulTruncatedNormal' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct StatefulTruncatedNormalInst {
    /// An instance of a fully built StatefulTruncatedNormal Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl StatefulTruncatedNormal {
    /// Creates a new `StatefulTruncatedNormal`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `dtype` attribute.
    pub fn dtype<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shape_dtype` attribute.
    pub fn shape_dtype<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.shape_dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `StatefulTruncatedNormal` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        resource: O0,
        algorithm: O1,
        shape: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(resource.into(), algorithm.into(), shape.into(), scope)
    }
    fn build_impl(
        &self,
        resource: crate::Output,
        algorithm: crate::Output,
        shape: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("StatefulTruncatedNormal", |nd| {
            nd.add_input(resource);
            nd.add_input(algorithm);
            nd.add_input(shape);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                nd.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shape_dtype {
                nd.set_attr_type("shape_dtype", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'StatefulTruncatedNormal' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        resource: crate::Output,
        algorithm: crate::Output,
        shape: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<StatefulTruncatedNormalInst> {
        let op = scope.new_operation("StatefulTruncatedNormal", |builder| {
            builder.add_input(resource);
            builder.add_input(algorithm);
            builder.add_input(shape);
            if let ::std::option::Option::Some(value) = &self.dtype {
                builder.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shape_dtype {
                builder.set_attr_type("shape_dtype", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(StatefulTruncatedNormalInst { op })
    }
}
impl StatefulTruncatedNormalInst {
    /// Returns the 'output' Output of this 'StatefulTruncatedNormal' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'resource' Input of this 'StatefulTruncatedNormal' operation.
    pub fn resource(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'algorithm' Input of this 'StatefulTruncatedNormal' operation.
    pub fn algorithm(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'shape' Input of this 'StatefulTruncatedNormal' operation.
    pub fn shape(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<StatefulTruncatedNormalInst> for crate::Operation {
    fn from(inst: StatefulTruncatedNormalInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `StatefulTruncatedNormal::new().build(resource, algorithm, shape, scope)`.
pub fn stateful_truncated_normal<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    resource: O0,
    algorithm: O1,
    shape: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    StatefulTruncatedNormal::new().build(resource, algorithm, shape, scope)
}

/// Builder for the `StatefulUniform` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct StatefulUniform {
    dtype: ::std::option::Option<crate::DataType>,
    shape_dtype: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'StatefulUniform' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct StatefulUniformInst {
    /// An instance of a fully built StatefulUniform Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl StatefulUniform {
    /// Creates a new `StatefulUniform`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `dtype` attribute.
    pub fn dtype<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shape_dtype` attribute.
    pub fn shape_dtype<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.shape_dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `StatefulUniform` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        resource: O0,
        algorithm: O1,
        shape: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(resource.into(), algorithm.into(), shape.into(), scope)
    }
    fn build_impl(
        &self,
        resource: crate::Output,
        algorithm: crate::Output,
        shape: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("StatefulUniform", |nd| {
            nd.add_input(resource);
            nd.add_input(algorithm);
            nd.add_input(shape);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                nd.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shape_dtype {
                nd.set_attr_type("shape_dtype", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'StatefulUniform' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        resource: crate::Output,
        algorithm: crate::Output,
        shape: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<StatefulUniformInst> {
        let op = scope.new_operation("StatefulUniform", |builder| {
            builder.add_input(resource);
            builder.add_input(algorithm);
            builder.add_input(shape);
            if let ::std::option::Option::Some(value) = &self.dtype {
                builder.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shape_dtype {
                builder.set_attr_type("shape_dtype", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(StatefulUniformInst { op })
    }
}
impl StatefulUniformInst {
    /// Returns the 'output' Output of this 'StatefulUniform' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'resource' Input of this 'StatefulUniform' operation.
    pub fn resource(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'algorithm' Input of this 'StatefulUniform' operation.
    pub fn algorithm(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'shape' Input of this 'StatefulUniform' operation.
    pub fn shape(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<StatefulUniformInst> for crate::Operation {
    fn from(inst: StatefulUniformInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `StatefulUniform::new().build(resource, algorithm, shape, scope)`.
pub fn stateful_uniform<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    resource: O0,
    algorithm: O1,
    shape: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    StatefulUniform::new().build(resource, algorithm, shape, scope)
}

/// Builder for the `StatefulUniformFullInt` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct StatefulUniformFullInt {
    dtype: ::std::option::Option<crate::DataType>,
    shape_dtype: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'StatefulUniformFullInt' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct StatefulUniformFullIntInst {
    /// An instance of a fully built StatefulUniformFullInt Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl StatefulUniformFullInt {
    /// Creates a new `StatefulUniformFullInt`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `dtype` attribute.
    pub fn dtype<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shape_dtype` attribute.
    pub fn shape_dtype<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.shape_dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `StatefulUniformFullInt` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        resource: O0,
        algorithm: O1,
        shape: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(resource.into(), algorithm.into(), shape.into(), scope)
    }
    fn build_impl(
        &self,
        resource: crate::Output,
        algorithm: crate::Output,
        shape: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("StatefulUniformFullInt", |nd| {
            nd.add_input(resource);
            nd.add_input(algorithm);
            nd.add_input(shape);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                nd.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shape_dtype {
                nd.set_attr_type("shape_dtype", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'StatefulUniformFullInt' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        resource: crate::Output,
        algorithm: crate::Output,
        shape: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<StatefulUniformFullIntInst> {
        let op = scope.new_operation("StatefulUniformFullInt", |builder| {
            builder.add_input(resource);
            builder.add_input(algorithm);
            builder.add_input(shape);
            if let ::std::option::Option::Some(value) = &self.dtype {
                builder.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shape_dtype {
                builder.set_attr_type("shape_dtype", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(StatefulUniformFullIntInst { op })
    }
}
impl StatefulUniformFullIntInst {
    /// Returns the 'output' Output of this 'StatefulUniformFullInt' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'resource' Input of this 'StatefulUniformFullInt' operation.
    pub fn resource(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'algorithm' Input of this 'StatefulUniformFullInt' operation.
    pub fn algorithm(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'shape' Input of this 'StatefulUniformFullInt' operation.
    pub fn shape(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<StatefulUniformFullIntInst> for crate::Operation {
    fn from(inst: StatefulUniformFullIntInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `StatefulUniformFullInt::new().build(resource, algorithm, shape, scope)`.
pub fn stateful_uniform_full_int<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    resource: O0,
    algorithm: O1,
    shape: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    StatefulUniformFullInt::new().build(resource, algorithm, shape, scope)
}

/// Builder for the `StatefulUniformInt` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct StatefulUniformInt {
    dtype: ::std::option::Option<crate::DataType>,
    shape_dtype: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'StatefulUniformInt' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct StatefulUniformIntInst {
    /// An instance of a fully built StatefulUniformInt Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl StatefulUniformInt {
    /// Creates a new `StatefulUniformInt`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `dtype` attribute.
    pub fn dtype<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shape_dtype` attribute.
    pub fn shape_dtype<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.shape_dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `StatefulUniformInt` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
    >(
        &self,
        resource: O0,
        algorithm: O1,
        shape: O2,
        minval: O3,
        maxval: O4,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            resource.into(),
            algorithm.into(),
            shape.into(),
            minval.into(),
            maxval.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        resource: crate::Output,
        algorithm: crate::Output,
        shape: crate::Output,
        minval: crate::Output,
        maxval: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("StatefulUniformInt", |nd| {
            nd.add_input(resource);
            nd.add_input(algorithm);
            nd.add_input(shape);
            nd.add_input(minval);
            nd.add_input(maxval);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                nd.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shape_dtype {
                nd.set_attr_type("shape_dtype", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'StatefulUniformInt' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        resource: crate::Output,
        algorithm: crate::Output,
        shape: crate::Output,
        minval: crate::Output,
        maxval: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<StatefulUniformIntInst> {
        let op = scope.new_operation("StatefulUniformInt", |builder| {
            builder.add_input(resource);
            builder.add_input(algorithm);
            builder.add_input(shape);
            builder.add_input(minval);
            builder.add_input(maxval);
            if let ::std::option::Option::Some(value) = &self.dtype {
                builder.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shape_dtype {
                builder.set_attr_type("shape_dtype", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(StatefulUniformIntInst { op })
    }
}
impl StatefulUniformIntInst {
    /// Returns the 'output' Output of this 'StatefulUniformInt' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'resource' Input of this 'StatefulUniformInt' operation.
    pub fn resource(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'algorithm' Input of this 'StatefulUniformInt' operation.
    pub fn algorithm(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'shape' Input of this 'StatefulUniformInt' operation.
    pub fn shape(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'minval' Input of this 'StatefulUniformInt' operation.
    pub fn minval(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'maxval' Input of this 'StatefulUniformInt' operation.
    pub fn maxval(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
}
impl From<StatefulUniformIntInst> for crate::Operation {
    fn from(inst: StatefulUniformIntInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `StatefulUniformInt::new().build(resource, algorithm, shape, minval, maxval, scope)`.
pub fn stateful_uniform_int<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
>(
    resource: O0,
    algorithm: O1,
    shape: O2,
    minval: O3,
    maxval: O4,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    StatefulUniformInt::new().build(resource, algorithm, shape, minval, maxval, scope)
}

/// Builder for the `StatelessCase` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct StatelessCase {
    Tin: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    Tout: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    branches: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'StatelessCase' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct StatelessCaseInst {
    /// An instance of a fully built StatelessCase Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl StatelessCase {
    /// Creates a new `StatelessCase`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `Tin` attribute.
    pub fn Tin<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tin = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tout` attribute.
    pub fn Tout<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tout = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `branches` attribute.
    pub fn branches<ArgType: ::std::convert::Into<::std::vec::Vec<::std::string::String>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.branches = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `StatelessCase` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        branch_index: O0,
        input: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(branch_index.into(), input.into(), scope)
    }
    fn build_impl(
        &self,
        branch_index: crate::Output,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("StatelessCase", |nd| {
            nd.add_input(branch_index);
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.Tin {
                nd.set_attr_type_list("Tin", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tout {
                nd.set_attr_type_list("Tout", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.branches {
                nd.set_attr_string_list("branches", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'StatelessCase' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        branch_index: crate::Output,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<StatelessCaseInst> {
        let op = scope.new_operation("StatelessCase", |builder| {
            builder.add_input(branch_index);
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.Tin {
                builder.set_attr_type_list("Tin", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tout {
                builder.set_attr_type_list("Tout", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.branches {
                builder.set_attr_string_list("branches", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(StatelessCaseInst { op })
    }
}
impl StatelessCaseInst {
    /// Returns the 'output' Output of this 'StatelessCase' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'branch_index' Input of this 'StatelessCase' operation.
    pub fn branch_index(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'StatelessCase' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<StatelessCaseInst> for crate::Operation {
    fn from(inst: StatelessCaseInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `StatelessCase::new().build(branch_index, input, scope)`.
pub fn stateless_case<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    branch_index: O0,
    input: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    StatelessCase::new().build(branch_index, input, scope)
}

/// Builder for the `StatelessIf` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct StatelessIf {
    Tcond: ::std::option::Option<crate::DataType>,
    Tin: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    Tout: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    then_branch: ::std::option::Option<::std::string::String>,
    else_branch: ::std::option::Option<::std::string::String>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'StatelessIf' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct StatelessIfInst {
    /// An instance of a fully built StatelessIf Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl StatelessIf {
    /// Creates a new `StatelessIf`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `Tcond` attribute.
    pub fn Tcond<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Tcond = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tin` attribute.
    pub fn Tin<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tin = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tout` attribute.
    pub fn Tout<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tout = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `then_branch` attribute.
    pub fn then_branch<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.then_branch = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `else_branch` attribute.
    pub fn else_branch<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.else_branch = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `StatelessIf` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        cond: O0,
        input: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(cond.into(), input.into(), scope)
    }
    fn build_impl(
        &self,
        cond: crate::Output,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("StatelessIf", |nd| {
            nd.add_input(cond);
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.Tcond {
                nd.set_attr_type("Tcond", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tin {
                nd.set_attr_type_list("Tin", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tout {
                nd.set_attr_type_list("Tout", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.then_branch {
                nd.set_attr_string("then_branch", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.else_branch {
                nd.set_attr_string("else_branch", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'StatelessIf' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        cond: crate::Output,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<StatelessIfInst> {
        let op = scope.new_operation("StatelessIf", |builder| {
            builder.add_input(cond);
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.Tcond {
                builder.set_attr_type("Tcond", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tin {
                builder.set_attr_type_list("Tin", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tout {
                builder.set_attr_type_list("Tout", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.then_branch {
                builder.set_attr_string("then_branch", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.else_branch {
                builder.set_attr_string("else_branch", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(StatelessIfInst { op })
    }
}
impl StatelessIfInst {
    /// Returns the 'output' Output of this 'StatelessIf' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'cond' Input of this 'StatelessIf' operation.
    pub fn cond(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'StatelessIf' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<StatelessIfInst> for crate::Operation {
    fn from(inst: StatelessIfInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `StatelessIf::new().build(cond, input, scope)`.
pub fn stateless_if<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    cond: O0,
    input: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    StatelessIf::new().build(cond, input, scope)
}

/// Builder for the `StatelessMultinomial` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct StatelessMultinomial {
    T: ::std::option::Option<crate::DataType>,
    Tseed: ::std::option::Option<crate::DataType>,
    output_dtype: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'StatelessMultinomial' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct StatelessMultinomialInst {
    /// An instance of a fully built StatelessMultinomial Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl StatelessMultinomial {
    /// Creates a new `StatelessMultinomial`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tseed` attribute.
    pub fn Tseed<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Tseed = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_dtype` attribute.
    pub fn output_dtype<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `StatelessMultinomial` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        logits: O0,
        num_samples: O1,
        seed: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(logits.into(), num_samples.into(), seed.into(), scope)
    }
    fn build_impl(
        &self,
        logits: crate::Output,
        num_samples: crate::Output,
        seed: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("StatelessMultinomial", |nd| {
            nd.add_input(logits);
            nd.add_input(num_samples);
            nd.add_input(seed);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tseed {
                nd.set_attr_type("Tseed", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_dtype {
                nd.set_attr_type("output_dtype", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'StatelessMultinomial' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        logits: crate::Output,
        num_samples: crate::Output,
        seed: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<StatelessMultinomialInst> {
        let op = scope.new_operation("StatelessMultinomial", |builder| {
            builder.add_input(logits);
            builder.add_input(num_samples);
            builder.add_input(seed);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tseed {
                builder.set_attr_type("Tseed", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_dtype {
                builder.set_attr_type("output_dtype", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(StatelessMultinomialInst { op })
    }
}
impl StatelessMultinomialInst {
    /// Returns the 'output' Output of this 'StatelessMultinomial' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'logits' Input of this 'StatelessMultinomial' operation.
    pub fn logits(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'num_samples' Input of this 'StatelessMultinomial' operation.
    pub fn num_samples(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'seed' Input of this 'StatelessMultinomial' operation.
    pub fn seed(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<StatelessMultinomialInst> for crate::Operation {
    fn from(inst: StatelessMultinomialInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `StatelessMultinomial::new().build(logits, num_samples, seed, scope)`.
pub fn stateless_multinomial<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    logits: O0,
    num_samples: O1,
    seed: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    StatelessMultinomial::new().build(logits, num_samples, seed, scope)
}

/// Builder for the `StatelessParameterizedTruncatedNormal` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct StatelessParameterizedTruncatedNormal {
    S: ::std::option::Option<crate::DataType>,
    Tseed: ::std::option::Option<crate::DataType>,
    dtype: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'StatelessParameterizedTruncatedNormal' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct StatelessParameterizedTruncatedNormalInst {
    /// An instance of a fully built StatelessParameterizedTruncatedNormal Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl StatelessParameterizedTruncatedNormal {
    /// Creates a new `StatelessParameterizedTruncatedNormal`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `S` attribute.
    pub fn S<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.S = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tseed` attribute.
    pub fn Tseed<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Tseed = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `dtype` attribute.
    pub fn dtype<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `StatelessParameterizedTruncatedNormal` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
    >(
        &self,
        shape: O0,
        seed: O1,
        means: O2,
        stddevs: O3,
        minvals: O4,
        maxvals: O5,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            shape.into(),
            seed.into(),
            means.into(),
            stddevs.into(),
            minvals.into(),
            maxvals.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        shape: crate::Output,
        seed: crate::Output,
        means: crate::Output,
        stddevs: crate::Output,
        minvals: crate::Output,
        maxvals: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("StatelessParameterizedTruncatedNormal", |nd| {
            nd.add_input(shape);
            nd.add_input(seed);
            nd.add_input(means);
            nd.add_input(stddevs);
            nd.add_input(minvals);
            nd.add_input(maxvals);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.S {
                nd.set_attr_type("S", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tseed {
                nd.set_attr_type("Tseed", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                nd.set_attr_type("dtype", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'StatelessParameterizedTruncatedNormal' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        shape: crate::Output,
        seed: crate::Output,
        means: crate::Output,
        stddevs: crate::Output,
        minvals: crate::Output,
        maxvals: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<StatelessParameterizedTruncatedNormalInst> {
        let op = scope.new_operation("StatelessParameterizedTruncatedNormal", |builder| {
            builder.add_input(shape);
            builder.add_input(seed);
            builder.add_input(means);
            builder.add_input(stddevs);
            builder.add_input(minvals);
            builder.add_input(maxvals);
            if let ::std::option::Option::Some(value) = &self.S {
                builder.set_attr_type("S", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tseed {
                builder.set_attr_type("Tseed", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                builder.set_attr_type("dtype", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(StatelessParameterizedTruncatedNormalInst { op })
    }
}
impl StatelessParameterizedTruncatedNormalInst {
    /// Returns the 'output' Output of this 'StatelessParameterizedTruncatedNormal' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'shape' Input of this 'StatelessParameterizedTruncatedNormal' operation.
    pub fn shape(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'seed' Input of this 'StatelessParameterizedTruncatedNormal' operation.
    pub fn seed(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'means' Input of this 'StatelessParameterizedTruncatedNormal' operation.
    pub fn means(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'stddevs' Input of this 'StatelessParameterizedTruncatedNormal' operation.
    pub fn stddevs(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'minvals' Input of this 'StatelessParameterizedTruncatedNormal' operation.
    pub fn minvals(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
    /// Returns the 'maxvals' Input of this 'StatelessParameterizedTruncatedNormal' operation.
    pub fn maxvals(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 5,
        }
    }
}
impl From<StatelessParameterizedTruncatedNormalInst> for crate::Operation {
    fn from(inst: StatelessParameterizedTruncatedNormalInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `StatelessParameterizedTruncatedNormal::new().build(shape, seed, means, stddevs, minvals, maxvals, scope)`.
pub fn stateless_parameterized_truncated_normal<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
>(
    shape: O0,
    seed: O1,
    means: O2,
    stddevs: O3,
    minvals: O4,
    maxvals: O5,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    StatelessParameterizedTruncatedNormal::new()
        .build(shape, seed, means, stddevs, minvals, maxvals, scope)
}

/// Builder for the `StatelessRandomBinomial` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct StatelessRandomBinomial {
    S: ::std::option::Option<crate::DataType>,
    Tseed: ::std::option::Option<crate::DataType>,
    T: ::std::option::Option<crate::DataType>,
    dtype: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'StatelessRandomBinomial' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct StatelessRandomBinomialInst {
    /// An instance of a fully built StatelessRandomBinomial Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl StatelessRandomBinomial {
    /// Creates a new `StatelessRandomBinomial`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `S` attribute.
    pub fn S<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.S = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tseed` attribute.
    pub fn Tseed<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Tseed = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `dtype` attribute.
    pub fn dtype<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `StatelessRandomBinomial` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
    >(
        &self,
        shape: O0,
        seed: O1,
        counts: O2,
        probs: O3,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            shape.into(),
            seed.into(),
            counts.into(),
            probs.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        shape: crate::Output,
        seed: crate::Output,
        counts: crate::Output,
        probs: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("StatelessRandomBinomial", |nd| {
            nd.add_input(shape);
            nd.add_input(seed);
            nd.add_input(counts);
            nd.add_input(probs);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.S {
                nd.set_attr_type("S", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tseed {
                nd.set_attr_type("Tseed", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                nd.set_attr_type("dtype", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'StatelessRandomBinomial' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        shape: crate::Output,
        seed: crate::Output,
        counts: crate::Output,
        probs: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<StatelessRandomBinomialInst> {
        let op = scope.new_operation("StatelessRandomBinomial", |builder| {
            builder.add_input(shape);
            builder.add_input(seed);
            builder.add_input(counts);
            builder.add_input(probs);
            if let ::std::option::Option::Some(value) = &self.S {
                builder.set_attr_type("S", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tseed {
                builder.set_attr_type("Tseed", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                builder.set_attr_type("dtype", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(StatelessRandomBinomialInst { op })
    }
}
impl StatelessRandomBinomialInst {
    /// Returns the 'output' Output of this 'StatelessRandomBinomial' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'shape' Input of this 'StatelessRandomBinomial' operation.
    pub fn shape(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'seed' Input of this 'StatelessRandomBinomial' operation.
    pub fn seed(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'counts' Input of this 'StatelessRandomBinomial' operation.
    pub fn counts(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'probs' Input of this 'StatelessRandomBinomial' operation.
    pub fn probs(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
}
impl From<StatelessRandomBinomialInst> for crate::Operation {
    fn from(inst: StatelessRandomBinomialInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `StatelessRandomBinomial::new().build(shape, seed, counts, probs, scope)`.
pub fn stateless_random_binomial<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
>(
    shape: O0,
    seed: O1,
    counts: O2,
    probs: O3,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    StatelessRandomBinomial::new().build(shape, seed, counts, probs, scope)
}

/// Builder for the `StatelessRandomGammaV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct StatelessRandomGammaV2 {
    dtype: ::std::option::Option<crate::DataType>,
    T: ::std::option::Option<crate::DataType>,
    Tseed: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'StatelessRandomGammaV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct StatelessRandomGammaV2Inst {
    /// An instance of a fully built StatelessRandomGammaV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl StatelessRandomGammaV2 {
    /// Creates a new `StatelessRandomGammaV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `dtype` attribute.
    pub fn dtype<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tseed` attribute.
    pub fn Tseed<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Tseed = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `StatelessRandomGammaV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        shape: O0,
        seed: O1,
        alpha: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(shape.into(), seed.into(), alpha.into(), scope)
    }
    fn build_impl(
        &self,
        shape: crate::Output,
        seed: crate::Output,
        alpha: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("StatelessRandomGammaV2", |nd| {
            nd.add_input(shape);
            nd.add_input(seed);
            nd.add_input(alpha);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                nd.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tseed {
                nd.set_attr_type("Tseed", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'StatelessRandomGammaV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        shape: crate::Output,
        seed: crate::Output,
        alpha: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<StatelessRandomGammaV2Inst> {
        let op = scope.new_operation("StatelessRandomGammaV2", |builder| {
            builder.add_input(shape);
            builder.add_input(seed);
            builder.add_input(alpha);
            if let ::std::option::Option::Some(value) = &self.dtype {
                builder.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tseed {
                builder.set_attr_type("Tseed", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(StatelessRandomGammaV2Inst { op })
    }
}
impl StatelessRandomGammaV2Inst {
    /// Returns the 'output' Output of this 'StatelessRandomGammaV2' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'shape' Input of this 'StatelessRandomGammaV2' operation.
    pub fn shape(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'seed' Input of this 'StatelessRandomGammaV2' operation.
    pub fn seed(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'alpha' Input of this 'StatelessRandomGammaV2' operation.
    pub fn alpha(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<StatelessRandomGammaV2Inst> for crate::Operation {
    fn from(inst: StatelessRandomGammaV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `StatelessRandomGammaV2::new().build(shape, seed, alpha, scope)`.
pub fn stateless_random_gamma_v2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    shape: O0,
    seed: O1,
    alpha: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    StatelessRandomGammaV2::new().build(shape, seed, alpha, scope)
}

/// Builder for the `StatelessRandomGammaV3` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct StatelessRandomGammaV3 {
    dtype: ::std::option::Option<crate::DataType>,
    shape_dtype: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'StatelessRandomGammaV3' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct StatelessRandomGammaV3Inst {
    /// An instance of a fully built StatelessRandomGammaV3 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl StatelessRandomGammaV3 {
    /// Creates a new `StatelessRandomGammaV3`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `dtype` attribute.
    pub fn dtype<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shape_dtype` attribute.
    pub fn shape_dtype<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.shape_dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `StatelessRandomGammaV3` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
    >(
        &self,
        shape: O0,
        key: O1,
        counter: O2,
        alg: O3,
        alpha: O4,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            shape.into(),
            key.into(),
            counter.into(),
            alg.into(),
            alpha.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        shape: crate::Output,
        key: crate::Output,
        counter: crate::Output,
        alg: crate::Output,
        alpha: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("StatelessRandomGammaV3", |nd| {
            nd.add_input(shape);
            nd.add_input(key);
            nd.add_input(counter);
            nd.add_input(alg);
            nd.add_input(alpha);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                nd.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shape_dtype {
                nd.set_attr_type("shape_dtype", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'StatelessRandomGammaV3' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        shape: crate::Output,
        key: crate::Output,
        counter: crate::Output,
        alg: crate::Output,
        alpha: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<StatelessRandomGammaV3Inst> {
        let op = scope.new_operation("StatelessRandomGammaV3", |builder| {
            builder.add_input(shape);
            builder.add_input(key);
            builder.add_input(counter);
            builder.add_input(alg);
            builder.add_input(alpha);
            if let ::std::option::Option::Some(value) = &self.dtype {
                builder.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shape_dtype {
                builder.set_attr_type("shape_dtype", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(StatelessRandomGammaV3Inst { op })
    }
}
impl StatelessRandomGammaV3Inst {
    /// Returns the 'output' Output of this 'StatelessRandomGammaV3' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'shape' Input of this 'StatelessRandomGammaV3' operation.
    pub fn shape(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'key' Input of this 'StatelessRandomGammaV3' operation.
    pub fn key(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'counter' Input of this 'StatelessRandomGammaV3' operation.
    pub fn counter(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'alg' Input of this 'StatelessRandomGammaV3' operation.
    pub fn alg(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'alpha' Input of this 'StatelessRandomGammaV3' operation.
    pub fn alpha(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
}
impl From<StatelessRandomGammaV3Inst> for crate::Operation {
    fn from(inst: StatelessRandomGammaV3Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `StatelessRandomGammaV3::new().build(shape, key, counter, alg, alpha, scope)`.
pub fn stateless_random_gamma_v3<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
>(
    shape: O0,
    key: O1,
    counter: O2,
    alg: O3,
    alpha: O4,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    StatelessRandomGammaV3::new().build(shape, key, counter, alg, alpha, scope)
}

/// Builder for the `StatelessRandomGetAlg` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct StatelessRandomGetAlg {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'StatelessRandomGetAlg' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct StatelessRandomGetAlgInst {
    /// An instance of a fully built StatelessRandomGetAlg Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl StatelessRandomGetAlg {
    /// Creates a new `StatelessRandomGetAlg`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `StatelessRandomGetAlg` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("StatelessRandomGetAlg", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'StatelessRandomGetAlg' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        scope: &mut crate::Scope,
    ) -> crate::Result<StatelessRandomGetAlgInst> {
        let op = scope.new_operation("StatelessRandomGetAlg", |builder| {
            ::std::result::Result::Ok(())
        })?;
        Ok(StatelessRandomGetAlgInst { op })
    }
}
impl StatelessRandomGetAlgInst {
    /// Returns the 'alg' Output of this 'StatelessRandomGetAlg' operation.
    pub fn alg(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
}
impl From<StatelessRandomGetAlgInst> for crate::Operation {
    fn from(inst: StatelessRandomGetAlgInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `StatelessRandomGetAlg::new().build(scope)`.
pub fn stateless_random_get_alg(scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
    StatelessRandomGetAlg::new().build(scope)
}

/// Builder for the `StatelessRandomGetKeyCounter` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct StatelessRandomGetKeyCounter {
    Tseed: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'StatelessRandomGetKeyCounter' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct StatelessRandomGetKeyCounterInst {
    /// An instance of a fully built StatelessRandomGetKeyCounter Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl StatelessRandomGetKeyCounter {
    /// Creates a new `StatelessRandomGetKeyCounter`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `Tseed` attribute.
    pub fn Tseed<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Tseed = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `StatelessRandomGetKeyCounter` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        seed: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(seed.into(), scope)
    }
    fn build_impl(
        &self,
        seed: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("StatelessRandomGetKeyCounter", |nd| {
            nd.add_input(seed);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.Tseed {
                nd.set_attr_type("Tseed", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'StatelessRandomGetKeyCounter' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        seed: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<StatelessRandomGetKeyCounterInst> {
        let op = scope.new_operation("StatelessRandomGetKeyCounter", |builder| {
            builder.add_input(seed);
            if let ::std::option::Option::Some(value) = &self.Tseed {
                builder.set_attr_type("Tseed", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(StatelessRandomGetKeyCounterInst { op })
    }
}
impl StatelessRandomGetKeyCounterInst {
    /// Returns the 'key' Output of this 'StatelessRandomGetKeyCounter' operation.
    pub fn key(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'counter' Output of this 'StatelessRandomGetKeyCounter' operation.
    pub fn counter(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'seed' Input of this 'StatelessRandomGetKeyCounter' operation.
    pub fn seed(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<StatelessRandomGetKeyCounterInst> for crate::Operation {
    fn from(inst: StatelessRandomGetKeyCounterInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `StatelessRandomGetKeyCounter::new().build(seed, scope)`.
pub fn stateless_random_get_key_counter<O0: ::std::convert::Into<crate::Output>>(
    seed: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    StatelessRandomGetKeyCounter::new().build(seed, scope)
}

/// Builder for the `StatelessRandomGetKeyCounterAlg` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct StatelessRandomGetKeyCounterAlg {
    Tseed: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'StatelessRandomGetKeyCounterAlg' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct StatelessRandomGetKeyCounterAlgInst {
    /// An instance of a fully built StatelessRandomGetKeyCounterAlg Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl StatelessRandomGetKeyCounterAlg {
    /// Creates a new `StatelessRandomGetKeyCounterAlg`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `Tseed` attribute.
    pub fn Tseed<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Tseed = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `StatelessRandomGetKeyCounterAlg` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        seed: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(seed.into(), scope)
    }
    fn build_impl(
        &self,
        seed: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("StatelessRandomGetKeyCounterAlg", |nd| {
            nd.add_input(seed);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.Tseed {
                nd.set_attr_type("Tseed", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'StatelessRandomGetKeyCounterAlg' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        seed: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<StatelessRandomGetKeyCounterAlgInst> {
        let op = scope.new_operation("StatelessRandomGetKeyCounterAlg", |builder| {
            builder.add_input(seed);
            if let ::std::option::Option::Some(value) = &self.Tseed {
                builder.set_attr_type("Tseed", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(StatelessRandomGetKeyCounterAlgInst { op })
    }
}
impl StatelessRandomGetKeyCounterAlgInst {
    /// Returns the 'key' Output of this 'StatelessRandomGetKeyCounterAlg' operation.
    pub fn key(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'counter' Output of this 'StatelessRandomGetKeyCounterAlg' operation.
    pub fn counter(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'alg' Output of this 'StatelessRandomGetKeyCounterAlg' operation.
    pub fn alg(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns the 'seed' Input of this 'StatelessRandomGetKeyCounterAlg' operation.
    pub fn seed(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<StatelessRandomGetKeyCounterAlgInst> for crate::Operation {
    fn from(inst: StatelessRandomGetKeyCounterAlgInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `StatelessRandomGetKeyCounterAlg::new().build(seed, scope)`.
pub fn stateless_random_get_key_counter_alg<O0: ::std::convert::Into<crate::Output>>(
    seed: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    StatelessRandomGetKeyCounterAlg::new().build(seed, scope)
}

/// Builder for the `StatelessRandomNormal` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct StatelessRandomNormal {
    dtype: ::std::option::Option<crate::DataType>,
    T: ::std::option::Option<crate::DataType>,
    Tseed: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'StatelessRandomNormal' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct StatelessRandomNormalInst {
    /// An instance of a fully built StatelessRandomNormal Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl StatelessRandomNormal {
    /// Creates a new `StatelessRandomNormal`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `dtype` attribute.
    pub fn dtype<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tseed` attribute.
    pub fn Tseed<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Tseed = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `StatelessRandomNormal` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        shape: O0,
        seed: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(shape.into(), seed.into(), scope)
    }
    fn build_impl(
        &self,
        shape: crate::Output,
        seed: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("StatelessRandomNormal", |nd| {
            nd.add_input(shape);
            nd.add_input(seed);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                nd.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tseed {
                nd.set_attr_type("Tseed", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'StatelessRandomNormal' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        shape: crate::Output,
        seed: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<StatelessRandomNormalInst> {
        let op = scope.new_operation("StatelessRandomNormal", |builder| {
            builder.add_input(shape);
            builder.add_input(seed);
            if let ::std::option::Option::Some(value) = &self.dtype {
                builder.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tseed {
                builder.set_attr_type("Tseed", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(StatelessRandomNormalInst { op })
    }
}
impl StatelessRandomNormalInst {
    /// Returns the 'output' Output of this 'StatelessRandomNormal' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'shape' Input of this 'StatelessRandomNormal' operation.
    pub fn shape(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'seed' Input of this 'StatelessRandomNormal' operation.
    pub fn seed(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<StatelessRandomNormalInst> for crate::Operation {
    fn from(inst: StatelessRandomNormalInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `StatelessRandomNormal::new().build(shape, seed, scope)`.
pub fn stateless_random_normal<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    shape: O0,
    seed: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    StatelessRandomNormal::new().build(shape, seed, scope)
}

/// Builder for the `StatelessRandomNormalV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct StatelessRandomNormalV2 {
    dtype: ::std::option::Option<crate::DataType>,
    Tshape: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'StatelessRandomNormalV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct StatelessRandomNormalV2Inst {
    /// An instance of a fully built StatelessRandomNormalV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl StatelessRandomNormalV2 {
    /// Creates a new `StatelessRandomNormalV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `dtype` attribute.
    pub fn dtype<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tshape` attribute.
    pub fn Tshape<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tshape = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `StatelessRandomNormalV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
    >(
        &self,
        shape: O0,
        key: O1,
        counter: O2,
        alg: O3,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(shape.into(), key.into(), counter.into(), alg.into(), scope)
    }
    fn build_impl(
        &self,
        shape: crate::Output,
        key: crate::Output,
        counter: crate::Output,
        alg: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("StatelessRandomNormalV2", |nd| {
            nd.add_input(shape);
            nd.add_input(key);
            nd.add_input(counter);
            nd.add_input(alg);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                nd.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tshape {
                nd.set_attr_type("Tshape", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'StatelessRandomNormalV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        shape: crate::Output,
        key: crate::Output,
        counter: crate::Output,
        alg: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<StatelessRandomNormalV2Inst> {
        let op = scope.new_operation("StatelessRandomNormalV2", |builder| {
            builder.add_input(shape);
            builder.add_input(key);
            builder.add_input(counter);
            builder.add_input(alg);
            if let ::std::option::Option::Some(value) = &self.dtype {
                builder.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tshape {
                builder.set_attr_type("Tshape", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(StatelessRandomNormalV2Inst { op })
    }
}
impl StatelessRandomNormalV2Inst {
    /// Returns the 'output' Output of this 'StatelessRandomNormalV2' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'shape' Input of this 'StatelessRandomNormalV2' operation.
    pub fn shape(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'key' Input of this 'StatelessRandomNormalV2' operation.
    pub fn key(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'counter' Input of this 'StatelessRandomNormalV2' operation.
    pub fn counter(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'alg' Input of this 'StatelessRandomNormalV2' operation.
    pub fn alg(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
}
impl From<StatelessRandomNormalV2Inst> for crate::Operation {
    fn from(inst: StatelessRandomNormalV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `StatelessRandomNormalV2::new().build(shape, key, counter, alg, scope)`.
pub fn stateless_random_normal_v2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
>(
    shape: O0,
    key: O1,
    counter: O2,
    alg: O3,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    StatelessRandomNormalV2::new().build(shape, key, counter, alg, scope)
}

/// Builder for the `StatelessRandomPoisson` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct StatelessRandomPoisson {
    Rtype: ::std::option::Option<crate::DataType>,
    dtype: ::std::option::Option<crate::DataType>,
    T: ::std::option::Option<crate::DataType>,
    Tseed: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'StatelessRandomPoisson' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct StatelessRandomPoissonInst {
    /// An instance of a fully built StatelessRandomPoisson Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl StatelessRandomPoisson {
    /// Creates a new `StatelessRandomPoisson`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `Rtype` attribute.
    pub fn Rtype<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Rtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `dtype` attribute.
    pub fn dtype<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tseed` attribute.
    pub fn Tseed<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Tseed = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `StatelessRandomPoisson` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        shape: O0,
        seed: O1,
        lam: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(shape.into(), seed.into(), lam.into(), scope)
    }
    fn build_impl(
        &self,
        shape: crate::Output,
        seed: crate::Output,
        lam: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("StatelessRandomPoisson", |nd| {
            nd.add_input(shape);
            nd.add_input(seed);
            nd.add_input(lam);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.Rtype {
                nd.set_attr_type("Rtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                nd.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tseed {
                nd.set_attr_type("Tseed", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'StatelessRandomPoisson' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        shape: crate::Output,
        seed: crate::Output,
        lam: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<StatelessRandomPoissonInst> {
        let op = scope.new_operation("StatelessRandomPoisson", |builder| {
            builder.add_input(shape);
            builder.add_input(seed);
            builder.add_input(lam);
            if let ::std::option::Option::Some(value) = &self.Rtype {
                builder.set_attr_type("Rtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                builder.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tseed {
                builder.set_attr_type("Tseed", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(StatelessRandomPoissonInst { op })
    }
}
impl StatelessRandomPoissonInst {
    /// Returns the 'output' Output of this 'StatelessRandomPoisson' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'shape' Input of this 'StatelessRandomPoisson' operation.
    pub fn shape(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'seed' Input of this 'StatelessRandomPoisson' operation.
    pub fn seed(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'lam' Input of this 'StatelessRandomPoisson' operation.
    pub fn lam(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<StatelessRandomPoissonInst> for crate::Operation {
    fn from(inst: StatelessRandomPoissonInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `StatelessRandomPoisson::new().build(shape, seed, lam, scope)`.
pub fn stateless_random_poisson<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    shape: O0,
    seed: O1,
    lam: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    StatelessRandomPoisson::new().build(shape, seed, lam, scope)
}

/// Builder for the `StatelessRandomUniform` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct StatelessRandomUniform {
    dtype: ::std::option::Option<crate::DataType>,
    T: ::std::option::Option<crate::DataType>,
    Tseed: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'StatelessRandomUniform' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct StatelessRandomUniformInst {
    /// An instance of a fully built StatelessRandomUniform Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl StatelessRandomUniform {
    /// Creates a new `StatelessRandomUniform`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `dtype` attribute.
    pub fn dtype<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tseed` attribute.
    pub fn Tseed<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Tseed = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `StatelessRandomUniform` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        shape: O0,
        seed: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(shape.into(), seed.into(), scope)
    }
    fn build_impl(
        &self,
        shape: crate::Output,
        seed: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("StatelessRandomUniform", |nd| {
            nd.add_input(shape);
            nd.add_input(seed);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                nd.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tseed {
                nd.set_attr_type("Tseed", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'StatelessRandomUniform' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        shape: crate::Output,
        seed: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<StatelessRandomUniformInst> {
        let op = scope.new_operation("StatelessRandomUniform", |builder| {
            builder.add_input(shape);
            builder.add_input(seed);
            if let ::std::option::Option::Some(value) = &self.dtype {
                builder.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tseed {
                builder.set_attr_type("Tseed", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(StatelessRandomUniformInst { op })
    }
}
impl StatelessRandomUniformInst {
    /// Returns the 'output' Output of this 'StatelessRandomUniform' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'shape' Input of this 'StatelessRandomUniform' operation.
    pub fn shape(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'seed' Input of this 'StatelessRandomUniform' operation.
    pub fn seed(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<StatelessRandomUniformInst> for crate::Operation {
    fn from(inst: StatelessRandomUniformInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `StatelessRandomUniform::new().build(shape, seed, scope)`.
pub fn stateless_random_uniform<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    shape: O0,
    seed: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    StatelessRandomUniform::new().build(shape, seed, scope)
}

/// Builder for the `StatelessRandomUniformFullInt` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct StatelessRandomUniformFullInt {
    dtype: ::std::option::Option<crate::DataType>,
    T: ::std::option::Option<crate::DataType>,
    Tseed: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'StatelessRandomUniformFullInt' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct StatelessRandomUniformFullIntInst {
    /// An instance of a fully built StatelessRandomUniformFullInt Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl StatelessRandomUniformFullInt {
    /// Creates a new `StatelessRandomUniformFullInt`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `dtype` attribute.
    pub fn dtype<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tseed` attribute.
    pub fn Tseed<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Tseed = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `StatelessRandomUniformFullInt` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        shape: O0,
        seed: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(shape.into(), seed.into(), scope)
    }
    fn build_impl(
        &self,
        shape: crate::Output,
        seed: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("StatelessRandomUniformFullInt", |nd| {
            nd.add_input(shape);
            nd.add_input(seed);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                nd.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tseed {
                nd.set_attr_type("Tseed", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'StatelessRandomUniformFullInt' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        shape: crate::Output,
        seed: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<StatelessRandomUniformFullIntInst> {
        let op = scope.new_operation("StatelessRandomUniformFullInt", |builder| {
            builder.add_input(shape);
            builder.add_input(seed);
            if let ::std::option::Option::Some(value) = &self.dtype {
                builder.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tseed {
                builder.set_attr_type("Tseed", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(StatelessRandomUniformFullIntInst { op })
    }
}
impl StatelessRandomUniformFullIntInst {
    /// Returns the 'output' Output of this 'StatelessRandomUniformFullInt' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'shape' Input of this 'StatelessRandomUniformFullInt' operation.
    pub fn shape(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'seed' Input of this 'StatelessRandomUniformFullInt' operation.
    pub fn seed(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<StatelessRandomUniformFullIntInst> for crate::Operation {
    fn from(inst: StatelessRandomUniformFullIntInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `StatelessRandomUniformFullInt::new().build(shape, seed, scope)`.
pub fn stateless_random_uniform_full_int<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    shape: O0,
    seed: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    StatelessRandomUniformFullInt::new().build(shape, seed, scope)
}

/// Builder for the `StatelessRandomUniformFullIntV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct StatelessRandomUniformFullIntV2 {
    dtype: ::std::option::Option<crate::DataType>,
    Tshape: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'StatelessRandomUniformFullIntV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct StatelessRandomUniformFullIntV2Inst {
    /// An instance of a fully built StatelessRandomUniformFullIntV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl StatelessRandomUniformFullIntV2 {
    /// Creates a new `StatelessRandomUniformFullIntV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `dtype` attribute.
    pub fn dtype<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tshape` attribute.
    pub fn Tshape<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tshape = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `StatelessRandomUniformFullIntV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
    >(
        &self,
        shape: O0,
        key: O1,
        counter: O2,
        alg: O3,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(shape.into(), key.into(), counter.into(), alg.into(), scope)
    }
    fn build_impl(
        &self,
        shape: crate::Output,
        key: crate::Output,
        counter: crate::Output,
        alg: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("StatelessRandomUniformFullIntV2", |nd| {
            nd.add_input(shape);
            nd.add_input(key);
            nd.add_input(counter);
            nd.add_input(alg);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                nd.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tshape {
                nd.set_attr_type("Tshape", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'StatelessRandomUniformFullIntV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        shape: crate::Output,
        key: crate::Output,
        counter: crate::Output,
        alg: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<StatelessRandomUniformFullIntV2Inst> {
        let op = scope.new_operation("StatelessRandomUniformFullIntV2", |builder| {
            builder.add_input(shape);
            builder.add_input(key);
            builder.add_input(counter);
            builder.add_input(alg);
            if let ::std::option::Option::Some(value) = &self.dtype {
                builder.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tshape {
                builder.set_attr_type("Tshape", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(StatelessRandomUniformFullIntV2Inst { op })
    }
}
impl StatelessRandomUniformFullIntV2Inst {
    /// Returns the 'output' Output of this 'StatelessRandomUniformFullIntV2' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'shape' Input of this 'StatelessRandomUniformFullIntV2' operation.
    pub fn shape(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'key' Input of this 'StatelessRandomUniformFullIntV2' operation.
    pub fn key(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'counter' Input of this 'StatelessRandomUniformFullIntV2' operation.
    pub fn counter(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'alg' Input of this 'StatelessRandomUniformFullIntV2' operation.
    pub fn alg(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
}
impl From<StatelessRandomUniformFullIntV2Inst> for crate::Operation {
    fn from(inst: StatelessRandomUniformFullIntV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `StatelessRandomUniformFullIntV2::new().build(shape, key, counter, alg, scope)`.
pub fn stateless_random_uniform_full_int_v2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
>(
    shape: O0,
    key: O1,
    counter: O2,
    alg: O3,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    StatelessRandomUniformFullIntV2::new().build(shape, key, counter, alg, scope)
}

/// Builder for the `StatelessRandomUniformInt` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct StatelessRandomUniformInt {
    dtype: ::std::option::Option<crate::DataType>,
    T: ::std::option::Option<crate::DataType>,
    Tseed: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'StatelessRandomUniformInt' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct StatelessRandomUniformIntInst {
    /// An instance of a fully built StatelessRandomUniformInt Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl StatelessRandomUniformInt {
    /// Creates a new `StatelessRandomUniformInt`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `dtype` attribute.
    pub fn dtype<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tseed` attribute.
    pub fn Tseed<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Tseed = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `StatelessRandomUniformInt` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
    >(
        &self,
        shape: O0,
        seed: O1,
        minval: O2,
        maxval: O3,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            shape.into(),
            seed.into(),
            minval.into(),
            maxval.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        shape: crate::Output,
        seed: crate::Output,
        minval: crate::Output,
        maxval: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("StatelessRandomUniformInt", |nd| {
            nd.add_input(shape);
            nd.add_input(seed);
            nd.add_input(minval);
            nd.add_input(maxval);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                nd.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tseed {
                nd.set_attr_type("Tseed", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'StatelessRandomUniformInt' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        shape: crate::Output,
        seed: crate::Output,
        minval: crate::Output,
        maxval: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<StatelessRandomUniformIntInst> {
        let op = scope.new_operation("StatelessRandomUniformInt", |builder| {
            builder.add_input(shape);
            builder.add_input(seed);
            builder.add_input(minval);
            builder.add_input(maxval);
            if let ::std::option::Option::Some(value) = &self.dtype {
                builder.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tseed {
                builder.set_attr_type("Tseed", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(StatelessRandomUniformIntInst { op })
    }
}
impl StatelessRandomUniformIntInst {
    /// Returns the 'output' Output of this 'StatelessRandomUniformInt' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'shape' Input of this 'StatelessRandomUniformInt' operation.
    pub fn shape(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'seed' Input of this 'StatelessRandomUniformInt' operation.
    pub fn seed(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'minval' Input of this 'StatelessRandomUniformInt' operation.
    pub fn minval(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'maxval' Input of this 'StatelessRandomUniformInt' operation.
    pub fn maxval(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
}
impl From<StatelessRandomUniformIntInst> for crate::Operation {
    fn from(inst: StatelessRandomUniformIntInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `StatelessRandomUniformInt::new().build(shape, seed, minval, maxval, scope)`.
pub fn stateless_random_uniform_int<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
>(
    shape: O0,
    seed: O1,
    minval: O2,
    maxval: O3,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    StatelessRandomUniformInt::new().build(shape, seed, minval, maxval, scope)
}

/// Builder for the `StatelessRandomUniformIntV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct StatelessRandomUniformIntV2 {
    dtype: ::std::option::Option<crate::DataType>,
    Tshape: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'StatelessRandomUniformIntV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct StatelessRandomUniformIntV2Inst {
    /// An instance of a fully built StatelessRandomUniformIntV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl StatelessRandomUniformIntV2 {
    /// Creates a new `StatelessRandomUniformIntV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `dtype` attribute.
    pub fn dtype<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tshape` attribute.
    pub fn Tshape<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tshape = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `StatelessRandomUniformIntV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
    >(
        &self,
        shape: O0,
        key: O1,
        counter: O2,
        alg: O3,
        minval: O4,
        maxval: O5,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            shape.into(),
            key.into(),
            counter.into(),
            alg.into(),
            minval.into(),
            maxval.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        shape: crate::Output,
        key: crate::Output,
        counter: crate::Output,
        alg: crate::Output,
        minval: crate::Output,
        maxval: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("StatelessRandomUniformIntV2", |nd| {
            nd.add_input(shape);
            nd.add_input(key);
            nd.add_input(counter);
            nd.add_input(alg);
            nd.add_input(minval);
            nd.add_input(maxval);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                nd.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tshape {
                nd.set_attr_type("Tshape", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'StatelessRandomUniformIntV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        shape: crate::Output,
        key: crate::Output,
        counter: crate::Output,
        alg: crate::Output,
        minval: crate::Output,
        maxval: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<StatelessRandomUniformIntV2Inst> {
        let op = scope.new_operation("StatelessRandomUniformIntV2", |builder| {
            builder.add_input(shape);
            builder.add_input(key);
            builder.add_input(counter);
            builder.add_input(alg);
            builder.add_input(minval);
            builder.add_input(maxval);
            if let ::std::option::Option::Some(value) = &self.dtype {
                builder.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tshape {
                builder.set_attr_type("Tshape", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(StatelessRandomUniformIntV2Inst { op })
    }
}
impl StatelessRandomUniformIntV2Inst {
    /// Returns the 'output' Output of this 'StatelessRandomUniformIntV2' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'shape' Input of this 'StatelessRandomUniformIntV2' operation.
    pub fn shape(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'key' Input of this 'StatelessRandomUniformIntV2' operation.
    pub fn key(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'counter' Input of this 'StatelessRandomUniformIntV2' operation.
    pub fn counter(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'alg' Input of this 'StatelessRandomUniformIntV2' operation.
    pub fn alg(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'minval' Input of this 'StatelessRandomUniformIntV2' operation.
    pub fn minval(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
    /// Returns the 'maxval' Input of this 'StatelessRandomUniformIntV2' operation.
    pub fn maxval(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 5,
        }
    }
}
impl From<StatelessRandomUniformIntV2Inst> for crate::Operation {
    fn from(inst: StatelessRandomUniformIntV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `StatelessRandomUniformIntV2::new().build(shape, key, counter, alg, minval, maxval, scope)`.
pub fn stateless_random_uniform_int_v2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
>(
    shape: O0,
    key: O1,
    counter: O2,
    alg: O3,
    minval: O4,
    maxval: O5,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    StatelessRandomUniformIntV2::new().build(shape, key, counter, alg, minval, maxval, scope)
}

/// Builder for the `StatelessRandomUniformV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct StatelessRandomUniformV2 {
    dtype: ::std::option::Option<crate::DataType>,
    Tshape: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'StatelessRandomUniformV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct StatelessRandomUniformV2Inst {
    /// An instance of a fully built StatelessRandomUniformV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl StatelessRandomUniformV2 {
    /// Creates a new `StatelessRandomUniformV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `dtype` attribute.
    pub fn dtype<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tshape` attribute.
    pub fn Tshape<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tshape = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `StatelessRandomUniformV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
    >(
        &self,
        shape: O0,
        key: O1,
        counter: O2,
        alg: O3,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(shape.into(), key.into(), counter.into(), alg.into(), scope)
    }
    fn build_impl(
        &self,
        shape: crate::Output,
        key: crate::Output,
        counter: crate::Output,
        alg: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("StatelessRandomUniformV2", |nd| {
            nd.add_input(shape);
            nd.add_input(key);
            nd.add_input(counter);
            nd.add_input(alg);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                nd.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tshape {
                nd.set_attr_type("Tshape", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'StatelessRandomUniformV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        shape: crate::Output,
        key: crate::Output,
        counter: crate::Output,
        alg: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<StatelessRandomUniformV2Inst> {
        let op = scope.new_operation("StatelessRandomUniformV2", |builder| {
            builder.add_input(shape);
            builder.add_input(key);
            builder.add_input(counter);
            builder.add_input(alg);
            if let ::std::option::Option::Some(value) = &self.dtype {
                builder.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tshape {
                builder.set_attr_type("Tshape", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(StatelessRandomUniformV2Inst { op })
    }
}
impl StatelessRandomUniformV2Inst {
    /// Returns the 'output' Output of this 'StatelessRandomUniformV2' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'shape' Input of this 'StatelessRandomUniformV2' operation.
    pub fn shape(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'key' Input of this 'StatelessRandomUniformV2' operation.
    pub fn key(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'counter' Input of this 'StatelessRandomUniformV2' operation.
    pub fn counter(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'alg' Input of this 'StatelessRandomUniformV2' operation.
    pub fn alg(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
}
impl From<StatelessRandomUniformV2Inst> for crate::Operation {
    fn from(inst: StatelessRandomUniformV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `StatelessRandomUniformV2::new().build(shape, key, counter, alg, scope)`.
pub fn stateless_random_uniform_v2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
>(
    shape: O0,
    key: O1,
    counter: O2,
    alg: O3,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    StatelessRandomUniformV2::new().build(shape, key, counter, alg, scope)
}

/// Builder for the `StatelessSampleDistortedBoundingBox` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct StatelessSampleDistortedBoundingBox {
    T: ::std::option::Option<crate::DataType>,
    Tseed: ::std::option::Option<crate::DataType>,
    aspect_ratio_range: ::std::option::Option<::std::vec::Vec<f32>>,
    area_range: ::std::option::Option<::std::vec::Vec<f32>>,
    max_attempts: ::std::option::Option<i64>,
    use_image_if_no_bounding_boxes: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'StatelessSampleDistortedBoundingBox' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct StatelessSampleDistortedBoundingBoxInst {
    /// An instance of a fully built StatelessSampleDistortedBoundingBox Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl StatelessSampleDistortedBoundingBox {
    /// Creates a new `StatelessSampleDistortedBoundingBox`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tseed` attribute.
    pub fn Tseed<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Tseed = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `aspect_ratio_range` attribute.
    pub fn aspect_ratio_range<ArgType: ::std::convert::Into<::std::vec::Vec<f32>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.aspect_ratio_range = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `area_range` attribute.
    pub fn area_range<ArgType: ::std::convert::Into<::std::vec::Vec<f32>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.area_range = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `max_attempts` attribute.
    pub fn max_attempts<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.max_attempts = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_image_if_no_bounding_boxes` attribute.
    pub fn use_image_if_no_bounding_boxes<ArgType: ::std::convert::Into<bool>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.use_image_if_no_bounding_boxes = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `StatelessSampleDistortedBoundingBox` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
    >(
        &self,
        image_size: O0,
        bounding_boxes: O1,
        min_object_covered: O2,
        seed: O3,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            image_size.into(),
            bounding_boxes.into(),
            min_object_covered.into(),
            seed.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        image_size: crate::Output,
        bounding_boxes: crate::Output,
        min_object_covered: crate::Output,
        seed: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("StatelessSampleDistortedBoundingBox", |nd| {
            nd.add_input(image_size);
            nd.add_input(bounding_boxes);
            nd.add_input(min_object_covered);
            nd.add_input(seed);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tseed {
                nd.set_attr_type("Tseed", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.aspect_ratio_range {
                nd.set_attr_float_list("aspect_ratio_range", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.area_range {
                nd.set_attr_float_list("area_range", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.max_attempts {
                nd.set_attr_int("max_attempts", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_image_if_no_bounding_boxes {
                nd.set_attr_bool("use_image_if_no_bounding_boxes", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'StatelessSampleDistortedBoundingBox' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        image_size: crate::Output,
        bounding_boxes: crate::Output,
        min_object_covered: crate::Output,
        seed: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<StatelessSampleDistortedBoundingBoxInst> {
        let op = scope.new_operation("StatelessSampleDistortedBoundingBox", |builder| {
            builder.add_input(image_size);
            builder.add_input(bounding_boxes);
            builder.add_input(min_object_covered);
            builder.add_input(seed);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tseed {
                builder.set_attr_type("Tseed", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.aspect_ratio_range {
                builder.set_attr_float_list("aspect_ratio_range", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.area_range {
                builder.set_attr_float_list("area_range", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.max_attempts {
                builder.set_attr_int("max_attempts", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_image_if_no_bounding_boxes {
                builder.set_attr_bool("use_image_if_no_bounding_boxes", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(StatelessSampleDistortedBoundingBoxInst { op })
    }
}
impl StatelessSampleDistortedBoundingBoxInst {
    /// Returns the 'begin' Output of this 'StatelessSampleDistortedBoundingBox' operation.
    pub fn begin(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'size' Output of this 'StatelessSampleDistortedBoundingBox' operation.
    pub fn size(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'bboxes' Output of this 'StatelessSampleDistortedBoundingBox' operation.
    pub fn bboxes(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns the 'image_size' Input of this 'StatelessSampleDistortedBoundingBox' operation.
    pub fn image_size(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'bounding_boxes' Input of this 'StatelessSampleDistortedBoundingBox' operation.
    pub fn bounding_boxes(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'min_object_covered' Input of this 'StatelessSampleDistortedBoundingBox' operation.
    pub fn min_object_covered(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'seed' Input of this 'StatelessSampleDistortedBoundingBox' operation.
    pub fn seed(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
}
impl From<StatelessSampleDistortedBoundingBoxInst> for crate::Operation {
    fn from(inst: StatelessSampleDistortedBoundingBoxInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `StatelessSampleDistortedBoundingBox::new().build(image_size, bounding_boxes, min_object_covered, seed, scope)`.
pub fn stateless_sample_distorted_bounding_box<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
>(
    image_size: O0,
    bounding_boxes: O1,
    min_object_covered: O2,
    seed: O3,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    StatelessSampleDistortedBoundingBox::new().build(
        image_size,
        bounding_boxes,
        min_object_covered,
        seed,
        scope,
    )
}

/// Builder for the `StatelessShuffle` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct StatelessShuffle {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'StatelessShuffle' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct StatelessShuffleInst {
    /// An instance of a fully built StatelessShuffle Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl StatelessShuffle {
    /// Creates a new `StatelessShuffle`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `StatelessShuffle` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
    >(
        &self,
        value: O0,
        key: O1,
        counter: O2,
        alg: O3,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(value.into(), key.into(), counter.into(), alg.into(), scope)
    }
    fn build_impl(
        &self,
        value: crate::Output,
        key: crate::Output,
        counter: crate::Output,
        alg: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("StatelessShuffle", |nd| {
            nd.add_input(value);
            nd.add_input(key);
            nd.add_input(counter);
            nd.add_input(alg);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'StatelessShuffle' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        value: crate::Output,
        key: crate::Output,
        counter: crate::Output,
        alg: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<StatelessShuffleInst> {
        let op = scope.new_operation("StatelessShuffle", |builder| {
            builder.add_input(value);
            builder.add_input(key);
            builder.add_input(counter);
            builder.add_input(alg);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(StatelessShuffleInst { op })
    }
}
impl StatelessShuffleInst {
    /// Returns the 'output' Output of this 'StatelessShuffle' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'value' Input of this 'StatelessShuffle' operation.
    pub fn value(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'key' Input of this 'StatelessShuffle' operation.
    pub fn key(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'counter' Input of this 'StatelessShuffle' operation.
    pub fn counter(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'alg' Input of this 'StatelessShuffle' operation.
    pub fn alg(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
}
impl From<StatelessShuffleInst> for crate::Operation {
    fn from(inst: StatelessShuffleInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `StatelessShuffle::new().build(value, key, counter, alg, scope)`.
pub fn stateless_shuffle<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
>(
    value: O0,
    key: O1,
    counter: O2,
    alg: O3,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    StatelessShuffle::new().build(value, key, counter, alg, scope)
}

/// Builder for the `StatelessTruncatedNormal` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct StatelessTruncatedNormal {
    dtype: ::std::option::Option<crate::DataType>,
    T: ::std::option::Option<crate::DataType>,
    Tseed: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'StatelessTruncatedNormal' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct StatelessTruncatedNormalInst {
    /// An instance of a fully built StatelessTruncatedNormal Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl StatelessTruncatedNormal {
    /// Creates a new `StatelessTruncatedNormal`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `dtype` attribute.
    pub fn dtype<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tseed` attribute.
    pub fn Tseed<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Tseed = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `StatelessTruncatedNormal` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        shape: O0,
        seed: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(shape.into(), seed.into(), scope)
    }
    fn build_impl(
        &self,
        shape: crate::Output,
        seed: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("StatelessTruncatedNormal", |nd| {
            nd.add_input(shape);
            nd.add_input(seed);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                nd.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tseed {
                nd.set_attr_type("Tseed", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'StatelessTruncatedNormal' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        shape: crate::Output,
        seed: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<StatelessTruncatedNormalInst> {
        let op = scope.new_operation("StatelessTruncatedNormal", |builder| {
            builder.add_input(shape);
            builder.add_input(seed);
            if let ::std::option::Option::Some(value) = &self.dtype {
                builder.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tseed {
                builder.set_attr_type("Tseed", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(StatelessTruncatedNormalInst { op })
    }
}
impl StatelessTruncatedNormalInst {
    /// Returns the 'output' Output of this 'StatelessTruncatedNormal' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'shape' Input of this 'StatelessTruncatedNormal' operation.
    pub fn shape(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'seed' Input of this 'StatelessTruncatedNormal' operation.
    pub fn seed(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<StatelessTruncatedNormalInst> for crate::Operation {
    fn from(inst: StatelessTruncatedNormalInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `StatelessTruncatedNormal::new().build(shape, seed, scope)`.
pub fn stateless_truncated_normal<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    shape: O0,
    seed: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    StatelessTruncatedNormal::new().build(shape, seed, scope)
}

/// Builder for the `StatelessTruncatedNormalV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct StatelessTruncatedNormalV2 {
    dtype: ::std::option::Option<crate::DataType>,
    Tshape: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'StatelessTruncatedNormalV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct StatelessTruncatedNormalV2Inst {
    /// An instance of a fully built StatelessTruncatedNormalV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl StatelessTruncatedNormalV2 {
    /// Creates a new `StatelessTruncatedNormalV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `dtype` attribute.
    pub fn dtype<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tshape` attribute.
    pub fn Tshape<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tshape = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `StatelessTruncatedNormalV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
    >(
        &self,
        shape: O0,
        key: O1,
        counter: O2,
        alg: O3,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(shape.into(), key.into(), counter.into(), alg.into(), scope)
    }
    fn build_impl(
        &self,
        shape: crate::Output,
        key: crate::Output,
        counter: crate::Output,
        alg: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("StatelessTruncatedNormalV2", |nd| {
            nd.add_input(shape);
            nd.add_input(key);
            nd.add_input(counter);
            nd.add_input(alg);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                nd.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tshape {
                nd.set_attr_type("Tshape", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'StatelessTruncatedNormalV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        shape: crate::Output,
        key: crate::Output,
        counter: crate::Output,
        alg: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<StatelessTruncatedNormalV2Inst> {
        let op = scope.new_operation("StatelessTruncatedNormalV2", |builder| {
            builder.add_input(shape);
            builder.add_input(key);
            builder.add_input(counter);
            builder.add_input(alg);
            if let ::std::option::Option::Some(value) = &self.dtype {
                builder.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tshape {
                builder.set_attr_type("Tshape", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(StatelessTruncatedNormalV2Inst { op })
    }
}
impl StatelessTruncatedNormalV2Inst {
    /// Returns the 'output' Output of this 'StatelessTruncatedNormalV2' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'shape' Input of this 'StatelessTruncatedNormalV2' operation.
    pub fn shape(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'key' Input of this 'StatelessTruncatedNormalV2' operation.
    pub fn key(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'counter' Input of this 'StatelessTruncatedNormalV2' operation.
    pub fn counter(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'alg' Input of this 'StatelessTruncatedNormalV2' operation.
    pub fn alg(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
}
impl From<StatelessTruncatedNormalV2Inst> for crate::Operation {
    fn from(inst: StatelessTruncatedNormalV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `StatelessTruncatedNormalV2::new().build(shape, key, counter, alg, scope)`.
pub fn stateless_truncated_normal_v2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
>(
    shape: O0,
    key: O1,
    counter: O2,
    alg: O3,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    StatelessTruncatedNormalV2::new().build(shape, key, counter, alg, scope)
}

/// Builder for the `StatelessWhile` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct StatelessWhile {
    T: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    cond: ::std::option::Option<::std::string::String>,
    body: ::std::option::Option<::std::string::String>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    parallel_iterations: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'StatelessWhile' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct StatelessWhileInst {
    /// An instance of a fully built StatelessWhile Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl StatelessWhile {
    /// Creates a new `StatelessWhile`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `cond` attribute.
    pub fn cond<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.cond = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `body` attribute.
    pub fn body<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.body = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `parallel_iterations` attribute.
    pub fn parallel_iterations<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.parallel_iterations = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `StatelessWhile` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("StatelessWhile", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type_list("T", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.cond {
                nd.set_attr_string("cond", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.body {
                nd.set_attr_string("body", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.parallel_iterations {
                nd.set_attr_int("parallel_iterations", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'StatelessWhile' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<StatelessWhileInst> {
        let op = scope.new_operation("StatelessWhile", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type_list("T", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.cond {
                builder.set_attr_string("cond", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.body {
                builder.set_attr_string("body", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.parallel_iterations {
                builder.set_attr_int("parallel_iterations", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(StatelessWhileInst { op })
    }
}
impl StatelessWhileInst {
    /// Returns the 'output' Output of this 'StatelessWhile' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'StatelessWhile' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<StatelessWhileInst> for crate::Operation {
    fn from(inst: StatelessWhileInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `StatelessWhile::new().build(input, scope)`.
pub fn stateless_while<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    StatelessWhile::new().build(input, scope)
}

/// Builder for the `StaticRegexFullMatch` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct StaticRegexFullMatch {
    pattern: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'StaticRegexFullMatch' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct StaticRegexFullMatchInst {
    /// An instance of a fully built StaticRegexFullMatch Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl StaticRegexFullMatch {
    /// Creates a new `StaticRegexFullMatch`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `pattern` attribute.
    pub fn pattern<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.pattern = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `StaticRegexFullMatch` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("StaticRegexFullMatch", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.pattern {
                nd.set_attr_string("pattern", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'StaticRegexFullMatch' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<StaticRegexFullMatchInst> {
        let op = scope.new_operation("StaticRegexFullMatch", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.pattern {
                builder.set_attr_string("pattern", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(StaticRegexFullMatchInst { op })
    }
}
impl StaticRegexFullMatchInst {
    /// Returns the 'output' Output of this 'StaticRegexFullMatch' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'StaticRegexFullMatch' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<StaticRegexFullMatchInst> for crate::Operation {
    fn from(inst: StaticRegexFullMatchInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `StaticRegexFullMatch::new().build(input, scope)`.
pub fn static_regex_full_match<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    StaticRegexFullMatch::new().build(input, scope)
}

/// Builder for the `StaticRegexReplace` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct StaticRegexReplace {
    pattern: ::std::option::Option<::std::string::String>,
    rewrite: ::std::option::Option<::std::string::String>,
    replace_global: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'StaticRegexReplace' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct StaticRegexReplaceInst {
    /// An instance of a fully built StaticRegexReplace Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl StaticRegexReplace {
    /// Creates a new `StaticRegexReplace`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `pattern` attribute.
    pub fn pattern<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.pattern = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `rewrite` attribute.
    pub fn rewrite<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.rewrite = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `replace_global` attribute.
    pub fn replace_global<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.replace_global = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `StaticRegexReplace` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("StaticRegexReplace", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.pattern {
                nd.set_attr_string("pattern", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.rewrite {
                nd.set_attr_string("rewrite", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.replace_global {
                nd.set_attr_bool("replace_global", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'StaticRegexReplace' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<StaticRegexReplaceInst> {
        let op = scope.new_operation("StaticRegexReplace", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.pattern {
                builder.set_attr_string("pattern", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.rewrite {
                builder.set_attr_string("rewrite", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.replace_global {
                builder.set_attr_bool("replace_global", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(StaticRegexReplaceInst { op })
    }
}
impl StaticRegexReplaceInst {
    /// Returns the 'output' Output of this 'StaticRegexReplace' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'StaticRegexReplace' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<StaticRegexReplaceInst> for crate::Operation {
    fn from(inst: StaticRegexReplaceInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `StaticRegexReplace::new().build(input, scope)`.
pub fn static_regex_replace<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    StaticRegexReplace::new().build(input, scope)
}

/// Builder for the `StatsAggregatorHandle` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct StatsAggregatorHandle {
    container: ::std::option::Option<::std::string::String>,
    shared_name: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'StatsAggregatorHandle' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct StatsAggregatorHandleInst {
    /// An instance of a fully built StatsAggregatorHandle Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl StatsAggregatorHandle {
    /// Creates a new `StatsAggregatorHandle`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `container` attribute.
    pub fn container<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.container = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shared_name` attribute.
    pub fn shared_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.shared_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `StatsAggregatorHandle` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("StatsAggregatorHandle", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.container {
                nd.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                nd.set_attr_string("shared_name", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'StatsAggregatorHandle' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        scope: &mut crate::Scope,
    ) -> crate::Result<StatsAggregatorHandleInst> {
        let op = scope.new_operation("StatsAggregatorHandle", |builder| {
            if let ::std::option::Option::Some(value) = &self.container {
                builder.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                builder.set_attr_string("shared_name", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(StatsAggregatorHandleInst { op })
    }
}
impl StatsAggregatorHandleInst {
    /// Returns the 'handle' Output of this 'StatsAggregatorHandle' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
}
impl From<StatsAggregatorHandleInst> for crate::Operation {
    fn from(inst: StatsAggregatorHandleInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `StatsAggregatorHandle::new().build(scope)`.
pub fn stats_aggregator_handle(scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
    StatsAggregatorHandle::new().build(scope)
}

/// Builder for the `StatsAggregatorHandleV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct StatsAggregatorHandleV2 {
    container: ::std::option::Option<::std::string::String>,
    shared_name: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'StatsAggregatorHandleV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct StatsAggregatorHandleV2Inst {
    /// An instance of a fully built StatsAggregatorHandleV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl StatsAggregatorHandleV2 {
    /// Creates a new `StatsAggregatorHandleV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `container` attribute.
    pub fn container<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.container = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shared_name` attribute.
    pub fn shared_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.shared_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `StatsAggregatorHandleV2` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("StatsAggregatorHandleV2", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.container {
                nd.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                nd.set_attr_string("shared_name", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'StatsAggregatorHandleV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        scope: &mut crate::Scope,
    ) -> crate::Result<StatsAggregatorHandleV2Inst> {
        let op = scope.new_operation("StatsAggregatorHandleV2", |builder| {
            if let ::std::option::Option::Some(value) = &self.container {
                builder.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                builder.set_attr_string("shared_name", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(StatsAggregatorHandleV2Inst { op })
    }
}
impl StatsAggregatorHandleV2Inst {
    /// Returns the 'handle' Output of this 'StatsAggregatorHandleV2' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
}
impl From<StatsAggregatorHandleV2Inst> for crate::Operation {
    fn from(inst: StatsAggregatorHandleV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `StatsAggregatorHandleV2::new().build(scope)`.
pub fn stats_aggregator_handle_v2(scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
    StatsAggregatorHandleV2::new().build(scope)
}

/// Builder for the `StatsAggregatorSetSummaryWriter` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct StatsAggregatorSetSummaryWriter {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'StatsAggregatorSetSummaryWriter' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct StatsAggregatorSetSummaryWriterInst {
    /// An instance of a fully built StatsAggregatorSetSummaryWriter Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl StatsAggregatorSetSummaryWriter {
    /// Creates a new `StatsAggregatorSetSummaryWriter`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `StatsAggregatorSetSummaryWriter` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        stats_aggregator: O0,
        summary: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(stats_aggregator.into(), summary.into(), scope)
    }
    fn build_impl(
        &self,
        stats_aggregator: crate::Output,
        summary: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("StatsAggregatorSetSummaryWriter", |nd| {
            nd.add_input(stats_aggregator);
            nd.add_input(summary);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'StatsAggregatorSetSummaryWriter' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        stats_aggregator: crate::Output,
        summary: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<StatsAggregatorSetSummaryWriterInst> {
        let op = scope.new_operation("StatsAggregatorSetSummaryWriter", |builder| {
            builder.add_input(stats_aggregator);
            builder.add_input(summary);
            ::std::result::Result::Ok(())
        })?;
        Ok(StatsAggregatorSetSummaryWriterInst { op })
    }
}
impl StatsAggregatorSetSummaryWriterInst {
    /// Returns the 'stats_aggregator' Input of this 'StatsAggregatorSetSummaryWriter' operation.
    pub fn stats_aggregator(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'summary' Input of this 'StatsAggregatorSetSummaryWriter' operation.
    pub fn summary(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<StatsAggregatorSetSummaryWriterInst> for crate::Operation {
    fn from(inst: StatsAggregatorSetSummaryWriterInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `StatsAggregatorSetSummaryWriter::new().build(stats_aggregator, summary, scope)`.
pub fn stats_aggregator_set_summary_writer<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    stats_aggregator: O0,
    summary: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    StatsAggregatorSetSummaryWriter::new().build(stats_aggregator, summary, scope)
}

/// Builder for the `StatsAggregatorSummary` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct StatsAggregatorSummary {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'StatsAggregatorSummary' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct StatsAggregatorSummaryInst {
    /// An instance of a fully built StatsAggregatorSummary Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl StatsAggregatorSummary {
    /// Creates a new `StatsAggregatorSummary`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `StatsAggregatorSummary` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        iterator: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(iterator.into(), scope)
    }
    fn build_impl(
        &self,
        iterator: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("StatsAggregatorSummary", |nd| {
            nd.add_input(iterator);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'StatsAggregatorSummary' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        iterator: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<StatsAggregatorSummaryInst> {
        let op = scope.new_operation("StatsAggregatorSummary", |builder| {
            builder.add_input(iterator);
            ::std::result::Result::Ok(())
        })?;
        Ok(StatsAggregatorSummaryInst { op })
    }
}
impl StatsAggregatorSummaryInst {
    /// Returns the 'summary' Output of this 'StatsAggregatorSummary' operation.
    pub fn summary(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'iterator' Input of this 'StatsAggregatorSummary' operation.
    pub fn iterator(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<StatsAggregatorSummaryInst> for crate::Operation {
    fn from(inst: StatsAggregatorSummaryInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `StatsAggregatorSummary::new().build(iterator, scope)`.
pub fn stats_aggregator_summary<O0: ::std::convert::Into<crate::Output>>(
    iterator: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    StatsAggregatorSummary::new().build(iterator, scope)
}

/// Builder for the `StochasticCastToInt` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct StochasticCastToInt {
    Tin: ::std::option::Option<crate::DataType>,
    Tout: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'StochasticCastToInt' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct StochasticCastToIntInst {
    /// An instance of a fully built StochasticCastToInt Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl StochasticCastToInt {
    /// Creates a new `StochasticCastToInt`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `Tin` attribute.
    pub fn Tin<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Tin = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tout` attribute.
    pub fn Tout<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Tout = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `StochasticCastToInt` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        key: O1,
        counter: O2,
        alg: O3,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), key.into(), counter.into(), alg.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        key: crate::Output,
        counter: crate::Output,
        alg: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("StochasticCastToInt", |nd| {
            nd.add_input(input);
            nd.add_input(key);
            nd.add_input(counter);
            nd.add_input(alg);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.Tin {
                nd.set_attr_type("Tin", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tout {
                nd.set_attr_type("Tout", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'StochasticCastToInt' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        key: crate::Output,
        counter: crate::Output,
        alg: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<StochasticCastToIntInst> {
        let op = scope.new_operation("StochasticCastToInt", |builder| {
            builder.add_input(input);
            builder.add_input(key);
            builder.add_input(counter);
            builder.add_input(alg);
            if let ::std::option::Option::Some(value) = &self.Tin {
                builder.set_attr_type("Tin", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tout {
                builder.set_attr_type("Tout", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(StochasticCastToIntInst { op })
    }
}
impl StochasticCastToIntInst {
    /// Returns the 'output' Output of this 'StochasticCastToInt' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'StochasticCastToInt' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'key' Input of this 'StochasticCastToInt' operation.
    pub fn key(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'counter' Input of this 'StochasticCastToInt' operation.
    pub fn counter(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'alg' Input of this 'StochasticCastToInt' operation.
    pub fn alg(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
}
impl From<StochasticCastToIntInst> for crate::Operation {
    fn from(inst: StochasticCastToIntInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `StochasticCastToInt::new().build(input, key, counter, alg, scope)`.
pub fn stochastic_cast_to_int<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
>(
    input: O0,
    key: O1,
    counter: O2,
    alg: O3,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    StochasticCastToInt::new().build(input, key, counter, alg, scope)
}

/// Builder for the `StopGradient` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct StopGradient {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'StopGradient' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct StopGradientInst {
    /// An instance of a fully built StopGradient Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl StopGradient {
    /// Creates a new `StopGradient`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `StopGradient` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("StopGradient", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'StopGradient' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<StopGradientInst> {
        let op = scope.new_operation("StopGradient", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(StopGradientInst { op })
    }
}
impl StopGradientInst {
    /// Returns the 'output' Output of this 'StopGradient' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'StopGradient' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<StopGradientInst> for crate::Operation {
    fn from(inst: StopGradientInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `StopGradient::new().build(input, scope)`.
pub fn stop_gradient<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    StopGradient::new().build(input, scope)
}

/// Builder for the `StridedSlice` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct StridedSlice {
    T: ::std::option::Option<crate::DataType>,
    Index: ::std::option::Option<crate::DataType>,
    begin_mask: ::std::option::Option<i64>,
    end_mask: ::std::option::Option<i64>,
    ellipsis_mask: ::std::option::Option<i64>,
    new_axis_mask: ::std::option::Option<i64>,
    shrink_axis_mask: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'StridedSlice' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct StridedSliceInst {
    /// An instance of a fully built StridedSlice Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl StridedSlice {
    /// Creates a new `StridedSlice`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Index` attribute.
    pub fn Index<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Index = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `begin_mask` attribute.
    pub fn begin_mask<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.begin_mask = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `end_mask` attribute.
    pub fn end_mask<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.end_mask = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `ellipsis_mask` attribute.
    pub fn ellipsis_mask<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.ellipsis_mask = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `new_axis_mask` attribute.
    pub fn new_axis_mask<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.new_axis_mask = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shrink_axis_mask` attribute.
    pub fn shrink_axis_mask<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.shrink_axis_mask = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `StridedSlice` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        begin: O1,
        end: O2,
        strides: O3,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            input.into(),
            begin.into(),
            end.into(),
            strides.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        input: crate::Output,
        begin: crate::Output,
        end: crate::Output,
        strides: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("StridedSlice", |nd| {
            nd.add_input(input);
            nd.add_input(begin);
            nd.add_input(end);
            nd.add_input(strides);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Index {
                nd.set_attr_type("Index", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.begin_mask {
                nd.set_attr_int("begin_mask", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.end_mask {
                nd.set_attr_int("end_mask", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.ellipsis_mask {
                nd.set_attr_int("ellipsis_mask", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.new_axis_mask {
                nd.set_attr_int("new_axis_mask", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shrink_axis_mask {
                nd.set_attr_int("shrink_axis_mask", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'StridedSlice' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        begin: crate::Output,
        end: crate::Output,
        strides: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<StridedSliceInst> {
        let op = scope.new_operation("StridedSlice", |builder| {
            builder.add_input(input);
            builder.add_input(begin);
            builder.add_input(end);
            builder.add_input(strides);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Index {
                builder.set_attr_type("Index", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.begin_mask {
                builder.set_attr_int("begin_mask", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.end_mask {
                builder.set_attr_int("end_mask", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.ellipsis_mask {
                builder.set_attr_int("ellipsis_mask", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.new_axis_mask {
                builder.set_attr_int("new_axis_mask", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shrink_axis_mask {
                builder.set_attr_int("shrink_axis_mask", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(StridedSliceInst { op })
    }
}
impl StridedSliceInst {
    /// Returns the 'output' Output of this 'StridedSlice' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'StridedSlice' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'begin' Input of this 'StridedSlice' operation.
    pub fn begin(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'end' Input of this 'StridedSlice' operation.
    pub fn end(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'strides' Input of this 'StridedSlice' operation.
    pub fn strides(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
}
impl From<StridedSliceInst> for crate::Operation {
    fn from(inst: StridedSliceInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `StridedSlice::new().build(input, begin, end, strides, scope)`.
pub fn strided_slice<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
>(
    input: O0,
    begin: O1,
    end: O2,
    strides: O3,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    StridedSlice::new().build(input, begin, end, strides, scope)
}

/// Builder for the `StridedSliceAssign` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct StridedSliceAssign {
    T: ::std::option::Option<crate::DataType>,
    Index: ::std::option::Option<crate::DataType>,
    begin_mask: ::std::option::Option<i64>,
    end_mask: ::std::option::Option<i64>,
    ellipsis_mask: ::std::option::Option<i64>,
    new_axis_mask: ::std::option::Option<i64>,
    shrink_axis_mask: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'StridedSliceAssign' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct StridedSliceAssignInst {
    /// An instance of a fully built StridedSliceAssign Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl StridedSliceAssign {
    /// Creates a new `StridedSliceAssign`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Index` attribute.
    pub fn Index<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Index = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `begin_mask` attribute.
    pub fn begin_mask<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.begin_mask = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `end_mask` attribute.
    pub fn end_mask<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.end_mask = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `ellipsis_mask` attribute.
    pub fn ellipsis_mask<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.ellipsis_mask = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `new_axis_mask` attribute.
    pub fn new_axis_mask<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.new_axis_mask = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shrink_axis_mask` attribute.
    pub fn shrink_axis_mask<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.shrink_axis_mask = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `StridedSliceAssign` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
    >(
        &self,
        ref_: O0,
        begin: O1,
        end: O2,
        strides: O3,
        value: O4,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            ref_.into(),
            begin.into(),
            end.into(),
            strides.into(),
            value.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        ref_: crate::Output,
        begin: crate::Output,
        end: crate::Output,
        strides: crate::Output,
        value: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("StridedSliceAssign", |nd| {
            nd.add_input(ref_);
            nd.add_input(begin);
            nd.add_input(end);
            nd.add_input(strides);
            nd.add_input(value);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Index {
                nd.set_attr_type("Index", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.begin_mask {
                nd.set_attr_int("begin_mask", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.end_mask {
                nd.set_attr_int("end_mask", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.ellipsis_mask {
                nd.set_attr_int("ellipsis_mask", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.new_axis_mask {
                nd.set_attr_int("new_axis_mask", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shrink_axis_mask {
                nd.set_attr_int("shrink_axis_mask", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'StridedSliceAssign' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        ref_: crate::Output,
        begin: crate::Output,
        end: crate::Output,
        strides: crate::Output,
        value: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<StridedSliceAssignInst> {
        let op = scope.new_operation("StridedSliceAssign", |builder| {
            builder.add_input(ref_);
            builder.add_input(begin);
            builder.add_input(end);
            builder.add_input(strides);
            builder.add_input(value);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Index {
                builder.set_attr_type("Index", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.begin_mask {
                builder.set_attr_int("begin_mask", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.end_mask {
                builder.set_attr_int("end_mask", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.ellipsis_mask {
                builder.set_attr_int("ellipsis_mask", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.new_axis_mask {
                builder.set_attr_int("new_axis_mask", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shrink_axis_mask {
                builder.set_attr_int("shrink_axis_mask", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(StridedSliceAssignInst { op })
    }
}
impl StridedSliceAssignInst {
    /// Returns the 'output_ref' Output of this 'StridedSliceAssign' operation.
    pub fn output_ref(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'ref_' Input of this 'StridedSliceAssign' operation.
    pub fn ref_(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'begin' Input of this 'StridedSliceAssign' operation.
    pub fn begin(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'end' Input of this 'StridedSliceAssign' operation.
    pub fn end(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'strides' Input of this 'StridedSliceAssign' operation.
    pub fn strides(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'value' Input of this 'StridedSliceAssign' operation.
    pub fn value(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
}
impl From<StridedSliceAssignInst> for crate::Operation {
    fn from(inst: StridedSliceAssignInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `StridedSliceAssign::new().build(ref_, begin, end, strides, value, scope)`.
pub fn strided_slice_assign<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
>(
    ref_: O0,
    begin: O1,
    end: O2,
    strides: O3,
    value: O4,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    StridedSliceAssign::new().build(ref_, begin, end, strides, value, scope)
}

/// Builder for the `StridedSliceGrad` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct StridedSliceGrad {
    T: ::std::option::Option<crate::DataType>,
    Index: ::std::option::Option<crate::DataType>,
    begin_mask: ::std::option::Option<i64>,
    end_mask: ::std::option::Option<i64>,
    ellipsis_mask: ::std::option::Option<i64>,
    new_axis_mask: ::std::option::Option<i64>,
    shrink_axis_mask: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'StridedSliceGrad' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct StridedSliceGradInst {
    /// An instance of a fully built StridedSliceGrad Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl StridedSliceGrad {
    /// Creates a new `StridedSliceGrad`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Index` attribute.
    pub fn Index<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Index = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `begin_mask` attribute.
    pub fn begin_mask<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.begin_mask = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `end_mask` attribute.
    pub fn end_mask<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.end_mask = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `ellipsis_mask` attribute.
    pub fn ellipsis_mask<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.ellipsis_mask = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `new_axis_mask` attribute.
    pub fn new_axis_mask<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.new_axis_mask = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shrink_axis_mask` attribute.
    pub fn shrink_axis_mask<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.shrink_axis_mask = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `StridedSliceGrad` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
    >(
        &self,
        shape: O0,
        begin: O1,
        end: O2,
        strides: O3,
        dy: O4,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            shape.into(),
            begin.into(),
            end.into(),
            strides.into(),
            dy.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        shape: crate::Output,
        begin: crate::Output,
        end: crate::Output,
        strides: crate::Output,
        dy: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("StridedSliceGrad", |nd| {
            nd.add_input(shape);
            nd.add_input(begin);
            nd.add_input(end);
            nd.add_input(strides);
            nd.add_input(dy);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Index {
                nd.set_attr_type("Index", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.begin_mask {
                nd.set_attr_int("begin_mask", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.end_mask {
                nd.set_attr_int("end_mask", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.ellipsis_mask {
                nd.set_attr_int("ellipsis_mask", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.new_axis_mask {
                nd.set_attr_int("new_axis_mask", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shrink_axis_mask {
                nd.set_attr_int("shrink_axis_mask", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'StridedSliceGrad' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        shape: crate::Output,
        begin: crate::Output,
        end: crate::Output,
        strides: crate::Output,
        dy: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<StridedSliceGradInst> {
        let op = scope.new_operation("StridedSliceGrad", |builder| {
            builder.add_input(shape);
            builder.add_input(begin);
            builder.add_input(end);
            builder.add_input(strides);
            builder.add_input(dy);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Index {
                builder.set_attr_type("Index", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.begin_mask {
                builder.set_attr_int("begin_mask", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.end_mask {
                builder.set_attr_int("end_mask", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.ellipsis_mask {
                builder.set_attr_int("ellipsis_mask", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.new_axis_mask {
                builder.set_attr_int("new_axis_mask", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shrink_axis_mask {
                builder.set_attr_int("shrink_axis_mask", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(StridedSliceGradInst { op })
    }
}
impl StridedSliceGradInst {
    /// Returns the 'output' Output of this 'StridedSliceGrad' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'shape' Input of this 'StridedSliceGrad' operation.
    pub fn shape(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'begin' Input of this 'StridedSliceGrad' operation.
    pub fn begin(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'end' Input of this 'StridedSliceGrad' operation.
    pub fn end(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'strides' Input of this 'StridedSliceGrad' operation.
    pub fn strides(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'dy' Input of this 'StridedSliceGrad' operation.
    pub fn dy(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
}
impl From<StridedSliceGradInst> for crate::Operation {
    fn from(inst: StridedSliceGradInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `StridedSliceGrad::new().build(shape, begin, end, strides, dy, scope)`.
pub fn strided_slice_grad<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
>(
    shape: O0,
    begin: O1,
    end: O2,
    strides: O3,
    dy: O4,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    StridedSliceGrad::new().build(shape, begin, end, strides, dy, scope)
}

/// Builder for the `StringFormat` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct StringFormat {
    T: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    template: ::std::option::Option<::std::string::String>,
    placeholder: ::std::option::Option<::std::string::String>,
    summarize: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'StringFormat' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct StringFormatInst {
    /// An instance of a fully built StringFormat Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl StringFormat {
    /// Creates a new `StringFormat`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `template` attribute.
    pub fn template<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.template = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `placeholder` attribute.
    pub fn placeholder<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.placeholder = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `summarize` attribute.
    pub fn summarize<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.summarize = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `StringFormat` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        inputs: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(inputs.into(), scope)
    }
    fn build_impl(
        &self,
        inputs: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("StringFormat", |nd| {
            nd.add_input(inputs);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type_list("T", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.template {
                nd.set_attr_string("template", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.placeholder {
                nd.set_attr_string("placeholder", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.summarize {
                nd.set_attr_int("summarize", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'StringFormat' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        inputs: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<StringFormatInst> {
        let op = scope.new_operation("StringFormat", |builder| {
            builder.add_input(inputs);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type_list("T", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.template {
                builder.set_attr_string("template", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.placeholder {
                builder.set_attr_string("placeholder", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.summarize {
                builder.set_attr_int("summarize", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(StringFormatInst { op })
    }
}
impl StringFormatInst {
    /// Returns the 'output' Output of this 'StringFormat' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'inputs' Input of this 'StringFormat' operation.
    pub fn inputs(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<StringFormatInst> for crate::Operation {
    fn from(inst: StringFormatInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `StringFormat::new().build(inputs, scope)`.
pub fn string_format<O0: ::std::convert::Into<crate::Output>>(
    inputs: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    StringFormat::new().build(inputs, scope)
}

/// Builder for the `StringJoin` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct StringJoin {
    N: ::std::option::Option<i64>,
    separator: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'StringJoin' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct StringJoinInst {
    /// An instance of a fully built StringJoin Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl StringJoin {
    /// Creates a new `StringJoin`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `N` attribute.
    pub fn N<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.N = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `separator` attribute.
    pub fn separator<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.separator = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `StringJoin` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        inputs: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(inputs.into(), scope)
    }
    fn build_impl(
        &self,
        inputs: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("StringJoin", |nd| {
            nd.add_input(inputs);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.N {
                nd.set_attr_int("N", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.separator {
                nd.set_attr_string("separator", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'StringJoin' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        inputs: Vec<crate::Output>,
        scope: &mut crate::Scope,
    ) -> crate::Result<StringJoinInst> {
        let op = scope.new_operation("StringJoin", |builder| {
            builder.add_input_list(&inputs);
            builder.set_attr_int("N", inputs.clone().len() as i64)?;
            if let ::std::option::Option::Some(value) = &self.separator {
                builder.set_attr_string("separator", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(StringJoinInst { op })
    }
}
impl StringJoinInst {
    /// Returns the 'output' Output of this 'StringJoin' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns a Vector of inputs for 'inputs' Input of this StringJoin operation.
    pub fn inputs(&self) -> crate::Result<Vec<crate::Input>> {
        let mut Inputs = vec![];
        for i in 0..self.op.get_attr_int("N")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
}
impl From<StringJoinInst> for crate::Operation {
    fn from(inst: StringJoinInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `StringJoin::new().build(inputs, scope)`.
pub fn string_join<O0: ::std::convert::Into<crate::Output>>(
    inputs: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    StringJoin::new().build(inputs, scope)
}

/// Builder for the `StringLength` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct StringLength {
    unit: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'StringLength' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct StringLengthInst {
    /// An instance of a fully built StringLength Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl StringLength {
    /// Creates a new `StringLength`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `unit` attribute.
    pub fn unit<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.unit = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `StringLength` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("StringLength", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.unit {
                nd.set_attr_string("unit", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'StringLength' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<StringLengthInst> {
        let op = scope.new_operation("StringLength", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.unit {
                builder.set_attr_string("unit", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(StringLengthInst { op })
    }
}
impl StringLengthInst {
    /// Returns the 'output' Output of this 'StringLength' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'StringLength' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<StringLengthInst> for crate::Operation {
    fn from(inst: StringLengthInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `StringLength::new().build(input, scope)`.
pub fn string_length<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    StringLength::new().build(input, scope)
}

/// Builder for the `StringLower` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct StringLower {
    encoding: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'StringLower' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct StringLowerInst {
    /// An instance of a fully built StringLower Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl StringLower {
    /// Creates a new `StringLower`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `encoding` attribute.
    pub fn encoding<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.encoding = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `StringLower` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("StringLower", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.encoding {
                nd.set_attr_string("encoding", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'StringLower' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<StringLowerInst> {
        let op = scope.new_operation("StringLower", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.encoding {
                builder.set_attr_string("encoding", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(StringLowerInst { op })
    }
}
impl StringLowerInst {
    /// Returns the 'output' Output of this 'StringLower' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'StringLower' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<StringLowerInst> for crate::Operation {
    fn from(inst: StringLowerInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `StringLower::new().build(input, scope)`.
pub fn string_lower<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    StringLower::new().build(input, scope)
}

/// Builder for the `StringNGrams` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct StringNGrams {
    separator: ::std::option::Option<::std::string::String>,
    ngram_widths: ::std::option::Option<::std::vec::Vec<i64>>,
    left_pad: ::std::option::Option<::std::string::String>,
    right_pad: ::std::option::Option<::std::string::String>,
    pad_width: ::std::option::Option<i64>,
    preserve_short_sequences: ::std::option::Option<bool>,
    Tsplits: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'StringNGrams' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct StringNGramsInst {
    /// An instance of a fully built StringNGrams Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl StringNGrams {
    /// Creates a new `StringNGrams`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `separator` attribute.
    pub fn separator<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.separator = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `ngram_widths` attribute.
    pub fn ngram_widths<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.ngram_widths = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `left_pad` attribute.
    pub fn left_pad<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.left_pad = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `right_pad` attribute.
    pub fn right_pad<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.right_pad = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `pad_width` attribute.
    pub fn pad_width<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.pad_width = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `preserve_short_sequences` attribute.
    pub fn preserve_short_sequences<ArgType: ::std::convert::Into<bool>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.preserve_short_sequences = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tsplits` attribute.
    pub fn Tsplits<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tsplits = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `StringNGrams` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        data: O0,
        data_splits: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(data.into(), data_splits.into(), scope)
    }
    fn build_impl(
        &self,
        data: crate::Output,
        data_splits: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("StringNGrams", |nd| {
            nd.add_input(data);
            nd.add_input(data_splits);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.separator {
                nd.set_attr_string("separator", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.ngram_widths {
                nd.set_attr_int_list("ngram_widths", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.left_pad {
                nd.set_attr_string("left_pad", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.right_pad {
                nd.set_attr_string("right_pad", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.pad_width {
                nd.set_attr_int("pad_width", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.preserve_short_sequences {
                nd.set_attr_bool("preserve_short_sequences", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tsplits {
                nd.set_attr_type("Tsplits", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'StringNGrams' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        data: crate::Output,
        data_splits: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<StringNGramsInst> {
        let op = scope.new_operation("StringNGrams", |builder| {
            builder.add_input(data);
            builder.add_input(data_splits);
            if let ::std::option::Option::Some(value) = &self.separator {
                builder.set_attr_string("separator", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.ngram_widths {
                builder.set_attr_int_list("ngram_widths", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.left_pad {
                builder.set_attr_string("left_pad", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.right_pad {
                builder.set_attr_string("right_pad", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.pad_width {
                builder.set_attr_int("pad_width", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.preserve_short_sequences {
                builder.set_attr_bool("preserve_short_sequences", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tsplits {
                builder.set_attr_type("Tsplits", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(StringNGramsInst { op })
    }
}
impl StringNGramsInst {
    /// Returns the 'ngrams' Output of this 'StringNGrams' operation.
    pub fn ngrams(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'ngrams_splits' Output of this 'StringNGrams' operation.
    pub fn ngrams_splits(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'data' Input of this 'StringNGrams' operation.
    pub fn data(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'data_splits' Input of this 'StringNGrams' operation.
    pub fn data_splits(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<StringNGramsInst> for crate::Operation {
    fn from(inst: StringNGramsInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `StringNGrams::new().build(data, data_splits, scope)`.
pub fn string_ngrams<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    data: O0,
    data_splits: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    StringNGrams::new().build(data, data_splits, scope)
}

/// Builder for the `StringSplit` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct StringSplit {
    skip_empty: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'StringSplit' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct StringSplitInst {
    /// An instance of a fully built StringSplit Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl StringSplit {
    /// Creates a new `StringSplit`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `skip_empty` attribute.
    pub fn skip_empty<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.skip_empty = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `StringSplit` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        delimiter: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), delimiter.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        delimiter: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("StringSplit", |nd| {
            nd.add_input(input);
            nd.add_input(delimiter);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.skip_empty {
                nd.set_attr_bool("skip_empty", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'StringSplit' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        delimiter: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<StringSplitInst> {
        let op = scope.new_operation("StringSplit", |builder| {
            builder.add_input(input);
            builder.add_input(delimiter);
            if let ::std::option::Option::Some(value) = &self.skip_empty {
                builder.set_attr_bool("skip_empty", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(StringSplitInst { op })
    }
}
impl StringSplitInst {
    /// Returns the 'indices' Output of this 'StringSplit' operation.
    pub fn indices(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'values' Output of this 'StringSplit' operation.
    pub fn values(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'shape' Output of this 'StringSplit' operation.
    pub fn shape(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns the 'input' Input of this 'StringSplit' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'delimiter' Input of this 'StringSplit' operation.
    pub fn delimiter(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<StringSplitInst> for crate::Operation {
    fn from(inst: StringSplitInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `StringSplit::new().build(input, delimiter, scope)`.
pub fn string_split<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    input: O0,
    delimiter: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    StringSplit::new().build(input, delimiter, scope)
}

/// Builder for the `StringSplitV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct StringSplitV2 {
    maxsplit: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'StringSplitV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct StringSplitV2Inst {
    /// An instance of a fully built StringSplitV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl StringSplitV2 {
    /// Creates a new `StringSplitV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `maxsplit` attribute.
    pub fn maxsplit<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.maxsplit = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `StringSplitV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        sep: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), sep.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        sep: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("StringSplitV2", |nd| {
            nd.add_input(input);
            nd.add_input(sep);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.maxsplit {
                nd.set_attr_int("maxsplit", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'StringSplitV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        sep: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<StringSplitV2Inst> {
        let op = scope.new_operation("StringSplitV2", |builder| {
            builder.add_input(input);
            builder.add_input(sep);
            if let ::std::option::Option::Some(value) = &self.maxsplit {
                builder.set_attr_int("maxsplit", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(StringSplitV2Inst { op })
    }
}
impl StringSplitV2Inst {
    /// Returns the 'indices' Output of this 'StringSplitV2' operation.
    pub fn indices(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'values' Output of this 'StringSplitV2' operation.
    pub fn values(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'shape' Output of this 'StringSplitV2' operation.
    pub fn shape(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns the 'input' Input of this 'StringSplitV2' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'sep' Input of this 'StringSplitV2' operation.
    pub fn sep(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<StringSplitV2Inst> for crate::Operation {
    fn from(inst: StringSplitV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `StringSplitV2::new().build(input, sep, scope)`.
pub fn string_split_v2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    input: O0,
    sep: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    StringSplitV2::new().build(input, sep, scope)
}

/// Builder for the `StringStrip` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct StringStrip {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'StringStrip' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct StringStripInst {
    /// An instance of a fully built StringStrip Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl StringStrip {
    /// Creates a new `StringStrip`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `StringStrip` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("StringStrip", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'StringStrip' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<StringStripInst> {
        let op = scope.new_operation("StringStrip", |builder| {
            builder.add_input(input);
            ::std::result::Result::Ok(())
        })?;
        Ok(StringStripInst { op })
    }
}
impl StringStripInst {
    /// Returns the 'output' Output of this 'StringStrip' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'StringStrip' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<StringStripInst> for crate::Operation {
    fn from(inst: StringStripInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `StringStrip::new().build(input, scope)`.
pub fn string_strip<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    StringStrip::new().build(input, scope)
}

/// Builder for the `StringToHashBucket` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct StringToHashBucket {
    num_buckets: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'StringToHashBucket' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct StringToHashBucketInst {
    /// An instance of a fully built StringToHashBucket Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl StringToHashBucket {
    /// Creates a new `StringToHashBucket`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `num_buckets` attribute.
    pub fn num_buckets<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.num_buckets = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `StringToHashBucket` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        string_tensor: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(string_tensor.into(), scope)
    }
    fn build_impl(
        &self,
        string_tensor: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("StringToHashBucket", |nd| {
            nd.add_input(string_tensor);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.num_buckets {
                nd.set_attr_int("num_buckets", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'StringToHashBucket' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        string_tensor: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<StringToHashBucketInst> {
        let op = scope.new_operation("StringToHashBucket", |builder| {
            builder.add_input(string_tensor);
            if let ::std::option::Option::Some(value) = &self.num_buckets {
                builder.set_attr_int("num_buckets", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(StringToHashBucketInst { op })
    }
}
impl StringToHashBucketInst {
    /// Returns the 'output' Output of this 'StringToHashBucket' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'string_tensor' Input of this 'StringToHashBucket' operation.
    pub fn string_tensor(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<StringToHashBucketInst> for crate::Operation {
    fn from(inst: StringToHashBucketInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `StringToHashBucket::new().build(string_tensor, scope)`.
pub fn string_to_hash_bucket<O0: ::std::convert::Into<crate::Output>>(
    string_tensor: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    StringToHashBucket::new().build(string_tensor, scope)
}

/// Builder for the `StringToHashBucketFast` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct StringToHashBucketFast {
    num_buckets: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'StringToHashBucketFast' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct StringToHashBucketFastInst {
    /// An instance of a fully built StringToHashBucketFast Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl StringToHashBucketFast {
    /// Creates a new `StringToHashBucketFast`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `num_buckets` attribute.
    pub fn num_buckets<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.num_buckets = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `StringToHashBucketFast` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("StringToHashBucketFast", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.num_buckets {
                nd.set_attr_int("num_buckets", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'StringToHashBucketFast' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<StringToHashBucketFastInst> {
        let op = scope.new_operation("StringToHashBucketFast", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.num_buckets {
                builder.set_attr_int("num_buckets", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(StringToHashBucketFastInst { op })
    }
}
impl StringToHashBucketFastInst {
    /// Returns the 'output' Output of this 'StringToHashBucketFast' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'StringToHashBucketFast' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<StringToHashBucketFastInst> for crate::Operation {
    fn from(inst: StringToHashBucketFastInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `StringToHashBucketFast::new().build(input, scope)`.
pub fn string_to_hash_bucket_fast<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    StringToHashBucketFast::new().build(input, scope)
}

/// Builder for the `StringToHashBucketStrong` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct StringToHashBucketStrong {
    num_buckets: ::std::option::Option<i64>,
    key: ::std::option::Option<::std::vec::Vec<i64>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'StringToHashBucketStrong' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct StringToHashBucketStrongInst {
    /// An instance of a fully built StringToHashBucketStrong Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl StringToHashBucketStrong {
    /// Creates a new `StringToHashBucketStrong`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `num_buckets` attribute.
    pub fn num_buckets<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.num_buckets = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `key` attribute.
    pub fn key<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.key = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `StringToHashBucketStrong` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("StringToHashBucketStrong", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.num_buckets {
                nd.set_attr_int("num_buckets", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.key {
                nd.set_attr_int_list("key", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'StringToHashBucketStrong' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<StringToHashBucketStrongInst> {
        let op = scope.new_operation("StringToHashBucketStrong", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.num_buckets {
                builder.set_attr_int("num_buckets", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.key {
                builder.set_attr_int_list("key", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(StringToHashBucketStrongInst { op })
    }
}
impl StringToHashBucketStrongInst {
    /// Returns the 'output' Output of this 'StringToHashBucketStrong' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'StringToHashBucketStrong' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<StringToHashBucketStrongInst> for crate::Operation {
    fn from(inst: StringToHashBucketStrongInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `StringToHashBucketStrong::new().build(input, scope)`.
pub fn string_to_hash_bucket_strong<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    StringToHashBucketStrong::new().build(input, scope)
}

/// Builder for the `StringToNumber` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct StringToNumber {
    out_type: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'StringToNumber' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct StringToNumberInst {
    /// An instance of a fully built StringToNumber Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl StringToNumber {
    /// Creates a new `StringToNumber`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `out_type` attribute.
    pub fn out_type<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.out_type = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `StringToNumber` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        string_tensor: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(string_tensor.into(), scope)
    }
    fn build_impl(
        &self,
        string_tensor: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("StringToNumber", |nd| {
            nd.add_input(string_tensor);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.out_type {
                nd.set_attr_type("out_type", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'StringToNumber' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        string_tensor: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<StringToNumberInst> {
        let op = scope.new_operation("StringToNumber", |builder| {
            builder.add_input(string_tensor);
            if let ::std::option::Option::Some(value) = &self.out_type {
                builder.set_attr_type("out_type", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(StringToNumberInst { op })
    }
}
impl StringToNumberInst {
    /// Returns the 'output' Output of this 'StringToNumber' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'string_tensor' Input of this 'StringToNumber' operation.
    pub fn string_tensor(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<StringToNumberInst> for crate::Operation {
    fn from(inst: StringToNumberInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `StringToNumber::new().build(string_tensor, scope)`.
pub fn string_to_number<O0: ::std::convert::Into<crate::Output>>(
    string_tensor: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    StringToNumber::new().build(string_tensor, scope)
}

/// Builder for the `StringUpper` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct StringUpper {
    encoding: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'StringUpper' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct StringUpperInst {
    /// An instance of a fully built StringUpper Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl StringUpper {
    /// Creates a new `StringUpper`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `encoding` attribute.
    pub fn encoding<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.encoding = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `StringUpper` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("StringUpper", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.encoding {
                nd.set_attr_string("encoding", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'StringUpper' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<StringUpperInst> {
        let op = scope.new_operation("StringUpper", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.encoding {
                builder.set_attr_string("encoding", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(StringUpperInst { op })
    }
}
impl StringUpperInst {
    /// Returns the 'output' Output of this 'StringUpper' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'StringUpper' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<StringUpperInst> for crate::Operation {
    fn from(inst: StringUpperInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `StringUpper::new().build(input, scope)`.
pub fn string_upper<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    StringUpper::new().build(input, scope)
}

/// Builder for the `Sub` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Sub {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Sub' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SubInst {
    /// An instance of a fully built Sub Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Sub {
    /// Creates a new `Sub`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Sub` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        x: O0,
        y: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), y.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        y: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Sub", |nd| {
            nd.add_input(x);
            nd.add_input(y);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Sub' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        y: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SubInst> {
        let op = scope.new_operation("Sub", |builder| {
            builder.add_input(x);
            builder.add_input(y);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SubInst { op })
    }
}
impl SubInst {
    /// Returns the 'z' Output of this 'Sub' operation.
    pub fn z(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'Sub' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'y' Input of this 'Sub' operation.
    pub fn y(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<SubInst> for crate::Operation {
    fn from(inst: SubInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Sub::new().build(x, y, scope)`.
pub fn sub<O0: ::std::convert::Into<crate::Output>, O1: ::std::convert::Into<crate::Output>>(
    x: O0,
    y: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Sub::new().build(x, y, scope)
}

/// Builder for the `Substr` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Substr {
    T: ::std::option::Option<crate::DataType>,
    unit: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Substr' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SubstrInst {
    /// An instance of a fully built Substr Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Substr {
    /// Creates a new `Substr`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `unit` attribute.
    pub fn unit<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.unit = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Substr` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        pos: O1,
        len: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), pos.into(), len.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        pos: crate::Output,
        len: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Substr", |nd| {
            nd.add_input(input);
            nd.add_input(pos);
            nd.add_input(len);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.unit {
                nd.set_attr_string("unit", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Substr' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        pos: crate::Output,
        len: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SubstrInst> {
        let op = scope.new_operation("Substr", |builder| {
            builder.add_input(input);
            builder.add_input(pos);
            builder.add_input(len);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.unit {
                builder.set_attr_string("unit", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SubstrInst { op })
    }
}
impl SubstrInst {
    /// Returns the 'output' Output of this 'Substr' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'Substr' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'pos' Input of this 'Substr' operation.
    pub fn pos(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'len' Input of this 'Substr' operation.
    pub fn len(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<SubstrInst> for crate::Operation {
    fn from(inst: SubstrInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Substr::new().build(input, pos, len, scope)`.
pub fn substr<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    input: O0,
    pos: O1,
    len: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Substr::new().build(input, pos, len, scope)
}

/// Builder for the `Sum` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Sum {
    keep_dims: ::std::option::Option<bool>,
    T: ::std::option::Option<crate::DataType>,
    Tidx: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Sum' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SumInst {
    /// An instance of a fully built Sum Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Sum {
    /// Creates a new `Sum`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `keep_dims` attribute.
    pub fn keep_dims<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.keep_dims = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tidx` attribute.
    pub fn Tidx<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Tidx = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Sum` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        reduction_indices: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), reduction_indices.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        reduction_indices: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Sum", |nd| {
            nd.add_input(input);
            nd.add_input(reduction_indices);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.keep_dims {
                nd.set_attr_bool("keep_dims", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tidx {
                nd.set_attr_type("Tidx", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Sum' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        reduction_indices: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SumInst> {
        let op = scope.new_operation("Sum", |builder| {
            builder.add_input(input);
            builder.add_input(reduction_indices);
            if let ::std::option::Option::Some(value) = &self.keep_dims {
                builder.set_attr_bool("keep_dims", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tidx {
                builder.set_attr_type("Tidx", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SumInst { op })
    }
}
impl SumInst {
    /// Returns the 'output' Output of this 'Sum' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'Sum' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'reduction_indices' Input of this 'Sum' operation.
    pub fn reduction_indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<SumInst> for crate::Operation {
    fn from(inst: SumInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Sum::new().build(input, reduction_indices, scope)`.
pub fn sum<O0: ::std::convert::Into<crate::Output>, O1: ::std::convert::Into<crate::Output>>(
    input: O0,
    reduction_indices: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Sum::new().build(input, reduction_indices, scope)
}

/// Builder for the `SummaryWriter` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SummaryWriter {
    shared_name: ::std::option::Option<::std::string::String>,
    container: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SummaryWriter' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SummaryWriterInst {
    /// An instance of a fully built SummaryWriter Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SummaryWriter {
    /// Creates a new `SummaryWriter`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `shared_name` attribute.
    pub fn shared_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.shared_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `container` attribute.
    pub fn container<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.container = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SummaryWriter` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("SummaryWriter", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                nd.set_attr_string("shared_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.container {
                nd.set_attr_string("container", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SummaryWriter' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(&self, scope: &mut crate::Scope) -> crate::Result<SummaryWriterInst> {
        let op = scope.new_operation("SummaryWriter", |builder| {
            if let ::std::option::Option::Some(value) = &self.shared_name {
                builder.set_attr_string("shared_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.container {
                builder.set_attr_string("container", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SummaryWriterInst { op })
    }
}
impl SummaryWriterInst {
    /// Returns the 'writer' Output of this 'SummaryWriter' operation.
    pub fn writer(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
}
impl From<SummaryWriterInst> for crate::Operation {
    fn from(inst: SummaryWriterInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SummaryWriter::new().build(scope)`.
pub fn summary_writer(scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
    SummaryWriter::new().build(scope)
}

/// Builder for the `Svd` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Svd {
    compute_uv: ::std::option::Option<bool>,
    full_matrices: ::std::option::Option<bool>,
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Svd' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SvdInst {
    /// An instance of a fully built Svd Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Svd {
    /// Creates a new `Svd`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `compute_uv` attribute.
    pub fn compute_uv<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.compute_uv = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `full_matrices` attribute.
    pub fn full_matrices<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.full_matrices = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Svd` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Svd", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.compute_uv {
                nd.set_attr_bool("compute_uv", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.full_matrices {
                nd.set_attr_bool("full_matrices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Svd' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SvdInst> {
        let op = scope.new_operation("Svd", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.compute_uv {
                builder.set_attr_bool("compute_uv", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.full_matrices {
                builder.set_attr_bool("full_matrices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SvdInst { op })
    }
}
impl SvdInst {
    /// Returns the 's' Output of this 'Svd' operation.
    pub fn s(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'u' Output of this 'Svd' operation.
    pub fn u(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'v' Output of this 'Svd' operation.
    pub fn v(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns the 'input' Input of this 'Svd' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<SvdInst> for crate::Operation {
    fn from(inst: SvdInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Svd::new().build(input, scope)`.
pub fn svd<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Svd::new().build(input, scope)
}

/// Builder for the `Switch` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Switch {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Switch' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SwitchInst {
    /// An instance of a fully built Switch Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Switch {
    /// Creates a new `Switch`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Switch` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        data: O0,
        pred: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(data.into(), pred.into(), scope)
    }
    fn build_impl(
        &self,
        data: crate::Output,
        pred: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Switch", |nd| {
            nd.add_input(data);
            nd.add_input(pred);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Switch' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        data: crate::Output,
        pred: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SwitchInst> {
        let op = scope.new_operation("Switch", |builder| {
            builder.add_input(data);
            builder.add_input(pred);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SwitchInst { op })
    }
}
impl SwitchInst {
    /// Returns the 'output_false' Output of this 'Switch' operation.
    pub fn output_false(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'output_true' Output of this 'Switch' operation.
    pub fn output_true(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'data' Input of this 'Switch' operation.
    pub fn data(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'pred' Input of this 'Switch' operation.
    pub fn pred(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<SwitchInst> for crate::Operation {
    fn from(inst: SwitchInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Switch::new().build(data, pred, scope)`.
pub fn switch<O0: ::std::convert::Into<crate::Output>, O1: ::std::convert::Into<crate::Output>>(
    data: O0,
    pred: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Switch::new().build(data, pred, scope)
}

/// Builder for the `SymbolicGradient` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SymbolicGradient {
    Tin: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    Tout: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    f: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SymbolicGradient' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SymbolicGradientInst {
    /// An instance of a fully built SymbolicGradient Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SymbolicGradient {
    /// Creates a new `SymbolicGradient`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `Tin` attribute.
    pub fn Tin<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tin = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tout` attribute.
    pub fn Tout<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tout = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `f` attribute.
    pub fn f<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.f = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SymbolicGradient` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("SymbolicGradient", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.Tin {
                nd.set_attr_type_list("Tin", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tout {
                nd.set_attr_type_list("Tout", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.f {
                nd.set_attr_string("f", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SymbolicGradient' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<SymbolicGradientInst> {
        let op = scope.new_operation("SymbolicGradient", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.Tin {
                builder.set_attr_type_list("Tin", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tout {
                builder.set_attr_type_list("Tout", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.f {
                builder.set_attr_string("f", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(SymbolicGradientInst { op })
    }
}
impl SymbolicGradientInst {
    /// Returns the 'output' Output of this 'SymbolicGradient' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'SymbolicGradient' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<SymbolicGradientInst> for crate::Operation {
    fn from(inst: SymbolicGradientInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SymbolicGradient::new().build(input, scope)`.
pub fn symbolic_gradient<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    SymbolicGradient::new().build(input, scope)
}

/// Builder for the `SyncDevice` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct SyncDevice {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'SyncDevice' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct SyncDeviceInst {
    /// An instance of a fully built SyncDevice Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl SyncDevice {
    /// Creates a new `SyncDevice`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `SyncDevice` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("SyncDevice", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'SyncDevice' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(&self, scope: &mut crate::Scope) -> crate::Result<SyncDeviceInst> {
        let op = scope.new_operation("SyncDevice", |builder| ::std::result::Result::Ok(()))?;
        Ok(SyncDeviceInst { op })
    }
}
impl SyncDeviceInst {}
impl From<SyncDeviceInst> for crate::Operation {
    fn from(inst: SyncDeviceInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `SyncDevice::new().build(scope)`.
pub fn sync_device(scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
    SyncDevice::new().build(scope)
}

/// Builder for the `TFRecordDataset` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct TFRecordDataset {
    metadata: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'TFRecordDataset' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct TFRecordDatasetInst {
    /// An instance of a fully built TFRecordDataset Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl TFRecordDataset {
    /// Creates a new `TFRecordDataset`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `metadata` attribute.
    pub fn metadata<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.metadata = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `TFRecordDataset` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        filenames: O0,
        compression_type: O1,
        buffer_size: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            filenames.into(),
            compression_type.into(),
            buffer_size.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        filenames: crate::Output,
        compression_type: crate::Output,
        buffer_size: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("TFRecordDataset", |nd| {
            nd.add_input(filenames);
            nd.add_input(compression_type);
            nd.add_input(buffer_size);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.metadata {
                nd.set_attr_string("metadata", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'TFRecordDataset' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        filenames: crate::Output,
        compression_type: crate::Output,
        buffer_size: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<TFRecordDatasetInst> {
        let op = scope.new_operation("TFRecordDataset", |builder| {
            builder.add_input(filenames);
            builder.add_input(compression_type);
            builder.add_input(buffer_size);
            if let ::std::option::Option::Some(value) = &self.metadata {
                builder.set_attr_string("metadata", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(TFRecordDatasetInst { op })
    }
}
impl TFRecordDatasetInst {
    /// Returns the 'handle' Output of this 'TFRecordDataset' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'filenames' Input of this 'TFRecordDataset' operation.
    pub fn filenames(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'compression_type' Input of this 'TFRecordDataset' operation.
    pub fn compression_type(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'buffer_size' Input of this 'TFRecordDataset' operation.
    pub fn buffer_size(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<TFRecordDatasetInst> for crate::Operation {
    fn from(inst: TFRecordDatasetInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `TFRecordDataset::new().build(filenames, compression_type, buffer_size, scope)`.
pub fn tfrecord_dataset<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    filenames: O0,
    compression_type: O1,
    buffer_size: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    TFRecordDataset::new().build(filenames, compression_type, buffer_size, scope)
}

/// Builder for the `TFRecordReader` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct TFRecordReader {
    container: ::std::option::Option<::std::string::String>,
    shared_name: ::std::option::Option<::std::string::String>,
    compression_type: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'TFRecordReader' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct TFRecordReaderInst {
    /// An instance of a fully built TFRecordReader Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl TFRecordReader {
    /// Creates a new `TFRecordReader`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `container` attribute.
    pub fn container<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.container = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shared_name` attribute.
    pub fn shared_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.shared_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `compression_type` attribute.
    pub fn compression_type<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.compression_type = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `TFRecordReader` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("TFRecordReader", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.container {
                nd.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                nd.set_attr_string("shared_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.compression_type {
                nd.set_attr_string("compression_type", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'TFRecordReader' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(&self, scope: &mut crate::Scope) -> crate::Result<TFRecordReaderInst> {
        let op = scope.new_operation("TFRecordReader", |builder| {
            if let ::std::option::Option::Some(value) = &self.container {
                builder.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                builder.set_attr_string("shared_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.compression_type {
                builder.set_attr_string("compression_type", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(TFRecordReaderInst { op })
    }
}
impl TFRecordReaderInst {
    /// Returns the 'reader_handle' Output of this 'TFRecordReader' operation.
    pub fn reader_handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
}
impl From<TFRecordReaderInst> for crate::Operation {
    fn from(inst: TFRecordReaderInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `TFRecordReader::new().build(scope)`.
pub fn tfrecord_reader(scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
    TFRecordReader::new().build(scope)
}

/// Builder for the `TFRecordReaderV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct TFRecordReaderV2 {
    container: ::std::option::Option<::std::string::String>,
    shared_name: ::std::option::Option<::std::string::String>,
    compression_type: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'TFRecordReaderV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct TFRecordReaderV2Inst {
    /// An instance of a fully built TFRecordReaderV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl TFRecordReaderV2 {
    /// Creates a new `TFRecordReaderV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `container` attribute.
    pub fn container<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.container = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shared_name` attribute.
    pub fn shared_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.shared_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `compression_type` attribute.
    pub fn compression_type<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.compression_type = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `TFRecordReaderV2` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("TFRecordReaderV2", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.container {
                nd.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                nd.set_attr_string("shared_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.compression_type {
                nd.set_attr_string("compression_type", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'TFRecordReaderV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(&self, scope: &mut crate::Scope) -> crate::Result<TFRecordReaderV2Inst> {
        let op = scope.new_operation("TFRecordReaderV2", |builder| {
            if let ::std::option::Option::Some(value) = &self.container {
                builder.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                builder.set_attr_string("shared_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.compression_type {
                builder.set_attr_string("compression_type", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(TFRecordReaderV2Inst { op })
    }
}
impl TFRecordReaderV2Inst {
    /// Returns the 'reader_handle' Output of this 'TFRecordReaderV2' operation.
    pub fn reader_handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
}
impl From<TFRecordReaderV2Inst> for crate::Operation {
    fn from(inst: TFRecordReaderV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `TFRecordReaderV2::new().build(scope)`.
pub fn tfrecord_reader_v2(scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
    TFRecordReaderV2::new().build(scope)
}

/// Builder for the `TPUCompilationResult` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct TPUCompilationResult {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'TPUCompilationResult' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct TPUCompilationResultInst {
    /// An instance of a fully built TPUCompilationResult Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl TPUCompilationResult {
    /// Creates a new `TPUCompilationResult`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `TPUCompilationResult` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("TPUCompilationResult", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'TPUCompilationResult' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        scope: &mut crate::Scope,
    ) -> crate::Result<TPUCompilationResultInst> {
        let op = scope.new_operation("TPUCompilationResult", |builder| {
            ::std::result::Result::Ok(())
        })?;
        Ok(TPUCompilationResultInst { op })
    }
}
impl TPUCompilationResultInst {
    /// Returns the 'output' Output of this 'TPUCompilationResult' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
}
impl From<TPUCompilationResultInst> for crate::Operation {
    fn from(inst: TPUCompilationResultInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `TPUCompilationResult::new().build(scope)`.
pub fn tpucompilation_result(scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
    TPUCompilationResult::new().build(scope)
}

/// Builder for the `TPUCompile` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct TPUCompile {
    num_computations: ::std::option::Option<i64>,
    function: ::std::option::Option<::std::string::String>,
    metadata: ::std::option::Option<::std::string::String>,
    NumDynamicShapes: ::std::option::Option<i64>,
    Tguaranteed_constants: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'TPUCompile' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct TPUCompileInst {
    /// An instance of a fully built TPUCompile Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl TPUCompile {
    /// Creates a new `TPUCompile`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `num_computations` attribute.
    pub fn num_computations<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.num_computations = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `function` attribute.
    pub fn function<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.function = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `metadata` attribute.
    pub fn metadata<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.metadata = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `NumDynamicShapes` attribute.
    pub fn NumDynamicShapes<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.NumDynamicShapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tguaranteed_constants` attribute.
    pub fn Tguaranteed_constants<
        ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>,
    >(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tguaranteed_constants = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `TPUCompile` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        dynamic_shapes: O0,
        guaranteed_constants: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(dynamic_shapes.into(), guaranteed_constants.into(), scope)
    }
    fn build_impl(
        &self,
        dynamic_shapes: crate::Output,
        guaranteed_constants: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("TPUCompile", |nd| {
            nd.add_input(dynamic_shapes);
            nd.add_input(guaranteed_constants);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.num_computations {
                nd.set_attr_int("num_computations", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.function {
                nd.set_attr_string("function", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.metadata {
                nd.set_attr_string("metadata", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.NumDynamicShapes {
                nd.set_attr_int("NumDynamicShapes", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tguaranteed_constants {
                nd.set_attr_type_list("Tguaranteed_constants", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'TPUCompile' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        dynamic_shapes: Vec<crate::Output>,
        guaranteed_constants: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<TPUCompileInst> {
        let op = scope.new_operation("TPUCompile", |builder| {
            builder.add_input_list(&dynamic_shapes);
            builder.add_input(guaranteed_constants);
            if let ::std::option::Option::Some(value) = &self.num_computations {
                builder.set_attr_int("num_computations", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.function {
                builder.set_attr_string("function", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.metadata {
                builder.set_attr_string("metadata", value)?;
            }
            builder.set_attr_int("NumDynamicShapes", dynamic_shapes.clone().len() as i64)?;
            if let ::std::option::Option::Some(value) = &self.Tguaranteed_constants {
                builder.set_attr_type_list("Tguaranteed_constants", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(TPUCompileInst { op })
    }
}
impl TPUCompileInst {
    /// Returns the 'compilation_status' Output of this 'TPUCompile' operation.
    pub fn compilation_status(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns a Vector of program for 'program' Output of this TPUCompile operation.
    pub fn program(&self) -> crate::Result<Vec<crate::Output>> {
        let mut Outputs = vec![];
        for i in 1..self.op.get_attr_int("num_computations")? as i32 {
            Outputs.push(crate::Output {
                operation: self.op.clone(),
                index: i,
            });
        }
        Ok(Outputs)
    }
    /// Returns a Vector of may_modify_variables for 'may_modify_variables' Output of this TPUCompile operation.
    pub fn may_modify_variables(&self) -> crate::Result<Vec<crate::Output>> {
        let dynamic_offset = (self.op.get_attr_int("num_computations")? + 2) as i32;
        let mut Outputs = vec![];
        for i in dynamic_offset..dynamic_offset + self.op.get_attr_int("num_computations")? as i32 {
            Outputs.push(crate::Output {
                operation: self.op.clone(),
                index: i,
            });
        }
        Ok(Outputs)
    }
    /// Returns a Vector of dynamic_shapes for 'dynamic_shapes' Input of this TPUCompile operation.
    pub fn dynamic_shapes(&self) -> crate::Result<Vec<crate::Input>> {
        let mut Inputs = vec![];
        for i in 0..self.op.get_attr_int("NumDynamicShapes")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
    /// Returns the 'guaranteed_constants' Input of this 'TPUCompile' operation.
    pub fn guaranteed_constants(&self) -> crate::Result<crate::Input> {
        let dynamic_offset = (self.op.get_attr_int("NumDynamicShapes")? + 1) as i32;
        Ok(crate::Input {
            operation: &self.op,
            index: dynamic_offset,
        })
    }
}
impl From<TPUCompileInst> for crate::Operation {
    fn from(inst: TPUCompileInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `TPUCompile::new().build(dynamic_shapes, guaranteed_constants, scope)`.
pub fn tpucompile<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    dynamic_shapes: O0,
    guaranteed_constants: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    TPUCompile::new().build(dynamic_shapes, guaranteed_constants, scope)
}

/// Builder for the `TPUCompileSucceededAssert` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct TPUCompileSucceededAssert {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'TPUCompileSucceededAssert' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct TPUCompileSucceededAssertInst {
    /// An instance of a fully built TPUCompileSucceededAssert Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl TPUCompileSucceededAssert {
    /// Creates a new `TPUCompileSucceededAssert`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `TPUCompileSucceededAssert` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        compilation_status: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(compilation_status.into(), scope)
    }
    fn build_impl(
        &self,
        compilation_status: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("TPUCompileSucceededAssert", |nd| {
            nd.add_input(compilation_status);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'TPUCompileSucceededAssert' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        compilation_status: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<TPUCompileSucceededAssertInst> {
        let op = scope.new_operation("TPUCompileSucceededAssert", |builder| {
            builder.add_input(compilation_status);
            ::std::result::Result::Ok(())
        })?;
        Ok(TPUCompileSucceededAssertInst { op })
    }
}
impl TPUCompileSucceededAssertInst {
    /// Returns the 'compilation_status' Input of this 'TPUCompileSucceededAssert' operation.
    pub fn compilation_status(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<TPUCompileSucceededAssertInst> for crate::Operation {
    fn from(inst: TPUCompileSucceededAssertInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `TPUCompileSucceededAssert::new().build(compilation_status, scope)`.
pub fn tpucompile_succeeded_assert<O0: ::std::convert::Into<crate::Output>>(
    compilation_status: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    TPUCompileSucceededAssert::new().build(compilation_status, scope)
}

/// Builder for the `TPUEmbeddingActivations` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct TPUEmbeddingActivations {
    table_id: ::std::option::Option<i64>,
    lookup_id: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'TPUEmbeddingActivations' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct TPUEmbeddingActivationsInst {
    /// An instance of a fully built TPUEmbeddingActivations Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl TPUEmbeddingActivations {
    /// Creates a new `TPUEmbeddingActivations`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `table_id` attribute.
    pub fn table_id<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.table_id = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `lookup_id` attribute.
    pub fn lookup_id<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.lookup_id = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `TPUEmbeddingActivations` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        embedding_variable: O0,
        sliced_activations: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(embedding_variable.into(), sliced_activations.into(), scope)
    }
    fn build_impl(
        &self,
        embedding_variable: crate::Output,
        sliced_activations: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("TPUEmbeddingActivations", |nd| {
            nd.add_input(embedding_variable);
            nd.add_input(sliced_activations);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.table_id {
                nd.set_attr_int("table_id", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.lookup_id {
                nd.set_attr_int("lookup_id", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'TPUEmbeddingActivations' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        embedding_variable: crate::Output,
        sliced_activations: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<TPUEmbeddingActivationsInst> {
        let op = scope.new_operation("TPUEmbeddingActivations", |builder| {
            builder.add_input(embedding_variable);
            builder.add_input(sliced_activations);
            if let ::std::option::Option::Some(value) = &self.table_id {
                builder.set_attr_int("table_id", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.lookup_id {
                builder.set_attr_int("lookup_id", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(TPUEmbeddingActivationsInst { op })
    }
}
impl TPUEmbeddingActivationsInst {
    /// Returns the 'output' Output of this 'TPUEmbeddingActivations' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'embedding_variable' Input of this 'TPUEmbeddingActivations' operation.
    pub fn embedding_variable(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'sliced_activations' Input of this 'TPUEmbeddingActivations' operation.
    pub fn sliced_activations(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<TPUEmbeddingActivationsInst> for crate::Operation {
    fn from(inst: TPUEmbeddingActivationsInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `TPUEmbeddingActivations::new().build(embedding_variable, sliced_activations, scope)`.
pub fn tpuembedding_activations<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    embedding_variable: O0,
    sliced_activations: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    TPUEmbeddingActivations::new().build(embedding_variable, sliced_activations, scope)
}

/// Builder for the `TPUExecute` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct TPUExecute {
    Targs: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    Tresults: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'TPUExecute' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct TPUExecuteInst {
    /// An instance of a fully built TPUExecute Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl TPUExecute {
    /// Creates a new `TPUExecute`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `Targs` attribute.
    pub fn Targs<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Targs = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tresults` attribute.
    pub fn Tresults<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tresults = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `TPUExecute` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        args: O0,
        key: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(args.into(), key.into(), scope)
    }
    fn build_impl(
        &self,
        args: crate::Output,
        key: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("TPUExecute", |nd| {
            nd.add_input(args);
            nd.add_input(key);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.Targs {
                nd.set_attr_type_list("Targs", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tresults {
                nd.set_attr_type_list("Tresults", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'TPUExecute' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        args: crate::Output,
        key: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<TPUExecuteInst> {
        let op = scope.new_operation("TPUExecute", |builder| {
            builder.add_input(args);
            builder.add_input(key);
            if let ::std::option::Option::Some(value) = &self.Targs {
                builder.set_attr_type_list("Targs", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tresults {
                builder.set_attr_type_list("Tresults", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(TPUExecuteInst { op })
    }
}
impl TPUExecuteInst {
    /// Returns the 'results' Output of this 'TPUExecute' operation.
    pub fn results(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'args' Input of this 'TPUExecute' operation.
    pub fn args(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'key' Input of this 'TPUExecute' operation.
    pub fn key(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<TPUExecuteInst> for crate::Operation {
    fn from(inst: TPUExecuteInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `TPUExecute::new().build(args, key, scope)`.
pub fn tpuexecute<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    args: O0,
    key: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    TPUExecute::new().build(args, key, scope)
}

/// Builder for the `TPUExecuteAndUpdateVariables` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct TPUExecuteAndUpdateVariables {
    Targs: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    Tresults: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    device_var_reads_indices: ::std::option::Option<::std::vec::Vec<i64>>,
    device_var_updates_indices: ::std::option::Option<::std::vec::Vec<i64>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'TPUExecuteAndUpdateVariables' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct TPUExecuteAndUpdateVariablesInst {
    /// An instance of a fully built TPUExecuteAndUpdateVariables Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl TPUExecuteAndUpdateVariables {
    /// Creates a new `TPUExecuteAndUpdateVariables`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `Targs` attribute.
    pub fn Targs<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Targs = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tresults` attribute.
    pub fn Tresults<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tresults = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `device_var_reads_indices` attribute.
    pub fn device_var_reads_indices<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.device_var_reads_indices = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `device_var_updates_indices` attribute.
    pub fn device_var_updates_indices<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.device_var_updates_indices = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `TPUExecuteAndUpdateVariables` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        args: O0,
        key: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(args.into(), key.into(), scope)
    }
    fn build_impl(
        &self,
        args: crate::Output,
        key: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("TPUExecuteAndUpdateVariables", |nd| {
            nd.add_input(args);
            nd.add_input(key);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.Targs {
                nd.set_attr_type_list("Targs", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tresults {
                nd.set_attr_type_list("Tresults", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.device_var_reads_indices {
                nd.set_attr_int_list("device_var_reads_indices", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.device_var_updates_indices {
                nd.set_attr_int_list("device_var_updates_indices", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'TPUExecuteAndUpdateVariables' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        args: crate::Output,
        key: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<TPUExecuteAndUpdateVariablesInst> {
        let op = scope.new_operation("TPUExecuteAndUpdateVariables", |builder| {
            builder.add_input(args);
            builder.add_input(key);
            if let ::std::option::Option::Some(value) = &self.Targs {
                builder.set_attr_type_list("Targs", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tresults {
                builder.set_attr_type_list("Tresults", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.device_var_reads_indices {
                builder.set_attr_int_list("device_var_reads_indices", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.device_var_updates_indices {
                builder.set_attr_int_list("device_var_updates_indices", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(TPUExecuteAndUpdateVariablesInst { op })
    }
}
impl TPUExecuteAndUpdateVariablesInst {
    /// Returns the 'results' Output of this 'TPUExecuteAndUpdateVariables' operation.
    pub fn results(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'args' Input of this 'TPUExecuteAndUpdateVariables' operation.
    pub fn args(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'key' Input of this 'TPUExecuteAndUpdateVariables' operation.
    pub fn key(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<TPUExecuteAndUpdateVariablesInst> for crate::Operation {
    fn from(inst: TPUExecuteAndUpdateVariablesInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `TPUExecuteAndUpdateVariables::new().build(args, key, scope)`.
pub fn tpuexecute_and_update_variables<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    args: O0,
    key: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    TPUExecuteAndUpdateVariables::new().build(args, key, scope)
}

/// Builder for the `TPUOrdinalSelector` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct TPUOrdinalSelector {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'TPUOrdinalSelector' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct TPUOrdinalSelectorInst {
    /// An instance of a fully built TPUOrdinalSelector Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl TPUOrdinalSelector {
    /// Creates a new `TPUOrdinalSelector`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `TPUOrdinalSelector` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("TPUOrdinalSelector", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'TPUOrdinalSelector' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        scope: &mut crate::Scope,
    ) -> crate::Result<TPUOrdinalSelectorInst> {
        let op =
            scope.new_operation(
                "TPUOrdinalSelector",
                |builder| ::std::result::Result::Ok(()),
            )?;
        Ok(TPUOrdinalSelectorInst { op })
    }
}
impl TPUOrdinalSelectorInst {
    /// Returns the 'device_ordinals' Output of this 'TPUOrdinalSelector' operation.
    pub fn device_ordinals(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
}
impl From<TPUOrdinalSelectorInst> for crate::Operation {
    fn from(inst: TPUOrdinalSelectorInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `TPUOrdinalSelector::new().build(scope)`.
pub fn tpuordinal_selector(scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
    TPUOrdinalSelector::new().build(scope)
}

/// Builder for the `TPUPartitionedCall` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct TPUPartitionedCall {
    Tin: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    Tout: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    f: ::std::option::Option<::std::string::String>,
    autotuner_thresh: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'TPUPartitionedCall' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct TPUPartitionedCallInst {
    /// An instance of a fully built TPUPartitionedCall Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl TPUPartitionedCall {
    /// Creates a new `TPUPartitionedCall`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `Tin` attribute.
    pub fn Tin<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tin = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tout` attribute.
    pub fn Tout<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tout = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `f` attribute.
    pub fn f<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.f = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `autotuner_thresh` attribute.
    pub fn autotuner_thresh<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.autotuner_thresh = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `TPUPartitionedCall` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        args: O0,
        device_ordinal: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(args.into(), device_ordinal.into(), scope)
    }
    fn build_impl(
        &self,
        args: crate::Output,
        device_ordinal: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("TPUPartitionedCall", |nd| {
            nd.add_input(args);
            nd.add_input(device_ordinal);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.Tin {
                nd.set_attr_type_list("Tin", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tout {
                nd.set_attr_type_list("Tout", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.f {
                nd.set_attr_string("f", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.autotuner_thresh {
                nd.set_attr_int("autotuner_thresh", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'TPUPartitionedCall' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        args: crate::Output,
        device_ordinal: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<TPUPartitionedCallInst> {
        let op = scope.new_operation("TPUPartitionedCall", |builder| {
            builder.add_input(args);
            builder.add_input(device_ordinal);
            if let ::std::option::Option::Some(value) = &self.Tin {
                builder.set_attr_type_list("Tin", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tout {
                builder.set_attr_type_list("Tout", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.f {
                builder.set_attr_string("f", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.autotuner_thresh {
                builder.set_attr_int("autotuner_thresh", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(TPUPartitionedCallInst { op })
    }
}
impl TPUPartitionedCallInst {
    /// Returns the 'output' Output of this 'TPUPartitionedCall' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'args' Input of this 'TPUPartitionedCall' operation.
    pub fn args(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'device_ordinal' Input of this 'TPUPartitionedCall' operation.
    pub fn device_ordinal(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<TPUPartitionedCallInst> for crate::Operation {
    fn from(inst: TPUPartitionedCallInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `TPUPartitionedCall::new().build(args, device_ordinal, scope)`.
pub fn tpupartitioned_call<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    args: O0,
    device_ordinal: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    TPUPartitionedCall::new().build(args, device_ordinal, scope)
}

/// Builder for the `TPUPartitionedInput` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct TPUPartitionedInput {
    N: ::std::option::Option<i64>,
    T: ::std::option::Option<crate::DataType>,
    partition_dim: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'TPUPartitionedInput' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct TPUPartitionedInputInst {
    /// An instance of a fully built TPUPartitionedInput Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl TPUPartitionedInput {
    /// Creates a new `TPUPartitionedInput`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `N` attribute.
    pub fn N<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.N = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `partition_dim` attribute.
    pub fn partition_dim<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.partition_dim = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `TPUPartitionedInput` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        inputs: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(inputs.into(), scope)
    }
    fn build_impl(
        &self,
        inputs: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("TPUPartitionedInput", |nd| {
            nd.add_input(inputs);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.N {
                nd.set_attr_int("N", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.partition_dim {
                nd.set_attr_int("partition_dim", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'TPUPartitionedInput' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        inputs: Vec<crate::Output>,
        scope: &mut crate::Scope,
    ) -> crate::Result<TPUPartitionedInputInst> {
        let op = scope.new_operation("TPUPartitionedInput", |builder| {
            builder.add_input_list(&inputs);
            builder.set_attr_int("N", inputs.clone().len() as i64)?;
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.partition_dim {
                builder.set_attr_int("partition_dim", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(TPUPartitionedInputInst { op })
    }
}
impl TPUPartitionedInputInst {
    /// Returns the 'output' Output of this 'TPUPartitionedInput' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns a Vector of inputs for 'inputs' Input of this TPUPartitionedInput operation.
    pub fn inputs(&self) -> crate::Result<Vec<crate::Input>> {
        let mut Inputs = vec![];
        for i in 0..self.op.get_attr_int("N")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
}
impl From<TPUPartitionedInputInst> for crate::Operation {
    fn from(inst: TPUPartitionedInputInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `TPUPartitionedInput::new().build(inputs, scope)`.
pub fn tpupartitioned_input<O0: ::std::convert::Into<crate::Output>>(
    inputs: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    TPUPartitionedInput::new().build(inputs, scope)
}

/// Builder for the `TPUPartitionedInputV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct TPUPartitionedInputV2 {
    N: ::std::option::Option<i64>,
    T: ::std::option::Option<crate::DataType>,
    partition_dims: ::std::option::Option<::std::vec::Vec<i64>>,
    is_packed: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'TPUPartitionedInputV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct TPUPartitionedInputV2Inst {
    /// An instance of a fully built TPUPartitionedInputV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl TPUPartitionedInputV2 {
    /// Creates a new `TPUPartitionedInputV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `N` attribute.
    pub fn N<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.N = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `partition_dims` attribute.
    pub fn partition_dims<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.partition_dims = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `is_packed` attribute.
    pub fn is_packed<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.is_packed = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `TPUPartitionedInputV2` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        inputs: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(inputs.into(), scope)
    }
    fn build_impl(
        &self,
        inputs: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("TPUPartitionedInputV2", |nd| {
            nd.add_input(inputs);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.N {
                nd.set_attr_int("N", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.partition_dims {
                nd.set_attr_int_list("partition_dims", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.is_packed {
                nd.set_attr_bool("is_packed", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'TPUPartitionedInputV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        inputs: Vec<crate::Output>,
        scope: &mut crate::Scope,
    ) -> crate::Result<TPUPartitionedInputV2Inst> {
        let op = scope.new_operation("TPUPartitionedInputV2", |builder| {
            builder.add_input_list(&inputs);
            builder.set_attr_int("N", inputs.clone().len() as i64)?;
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.partition_dims {
                builder.set_attr_int_list("partition_dims", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.is_packed {
                builder.set_attr_bool("is_packed", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(TPUPartitionedInputV2Inst { op })
    }
}
impl TPUPartitionedInputV2Inst {
    /// Returns the 'output' Output of this 'TPUPartitionedInputV2' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns a Vector of inputs for 'inputs' Input of this TPUPartitionedInputV2 operation.
    pub fn inputs(&self) -> crate::Result<Vec<crate::Input>> {
        let mut Inputs = vec![];
        for i in 0..self.op.get_attr_int("N")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
}
impl From<TPUPartitionedInputV2Inst> for crate::Operation {
    fn from(inst: TPUPartitionedInputV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `TPUPartitionedInputV2::new().build(inputs, scope)`.
pub fn tpupartitioned_input_v2<O0: ::std::convert::Into<crate::Output>>(
    inputs: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    TPUPartitionedInputV2::new().build(inputs, scope)
}

/// Builder for the `TPUPartitionedOutput` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct TPUPartitionedOutput {
    T: ::std::option::Option<crate::DataType>,
    num_splits: ::std::option::Option<i64>,
    partition_dim: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'TPUPartitionedOutput' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct TPUPartitionedOutputInst {
    /// An instance of a fully built TPUPartitionedOutput Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl TPUPartitionedOutput {
    /// Creates a new `TPUPartitionedOutput`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `num_splits` attribute.
    pub fn num_splits<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.num_splits = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `partition_dim` attribute.
    pub fn partition_dim<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.partition_dim = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `TPUPartitionedOutput` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        inputs: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(inputs.into(), scope)
    }
    fn build_impl(
        &self,
        inputs: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("TPUPartitionedOutput", |nd| {
            nd.add_input(inputs);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_splits {
                nd.set_attr_int("num_splits", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.partition_dim {
                nd.set_attr_int("partition_dim", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'TPUPartitionedOutput' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        inputs: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<TPUPartitionedOutputInst> {
        let op = scope.new_operation("TPUPartitionedOutput", |builder| {
            builder.add_input(inputs);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_splits {
                builder.set_attr_int("num_splits", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.partition_dim {
                builder.set_attr_int("partition_dim", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(TPUPartitionedOutputInst { op })
    }
}
impl TPUPartitionedOutputInst {
    /// Returns a Vector of output for 'output' Output of this TPUPartitionedOutput operation.
    pub fn output(&self) -> crate::Result<Vec<crate::Output>> {
        let mut Outputs = vec![];
        for i in 0..self.op.get_attr_int("num_splits")? as i32 {
            Outputs.push(crate::Output {
                operation: self.op.clone(),
                index: i,
            });
        }
        Ok(Outputs)
    }
    /// Returns the 'inputs' Input of this 'TPUPartitionedOutput' operation.
    pub fn inputs(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<TPUPartitionedOutputInst> for crate::Operation {
    fn from(inst: TPUPartitionedOutputInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `TPUPartitionedOutput::new().build(inputs, scope)`.
pub fn tpupartitioned_output<O0: ::std::convert::Into<crate::Output>>(
    inputs: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    TPUPartitionedOutput::new().build(inputs, scope)
}

/// Builder for the `TPUPartitionedOutputV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct TPUPartitionedOutputV2 {
    T: ::std::option::Option<crate::DataType>,
    num_splits: ::std::option::Option<i64>,
    partition_dims: ::std::option::Option<::std::vec::Vec<i64>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'TPUPartitionedOutputV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct TPUPartitionedOutputV2Inst {
    /// An instance of a fully built TPUPartitionedOutputV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl TPUPartitionedOutputV2 {
    /// Creates a new `TPUPartitionedOutputV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `num_splits` attribute.
    pub fn num_splits<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.num_splits = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `partition_dims` attribute.
    pub fn partition_dims<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.partition_dims = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `TPUPartitionedOutputV2` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        inputs: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(inputs.into(), scope)
    }
    fn build_impl(
        &self,
        inputs: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("TPUPartitionedOutputV2", |nd| {
            nd.add_input(inputs);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_splits {
                nd.set_attr_int("num_splits", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.partition_dims {
                nd.set_attr_int_list("partition_dims", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'TPUPartitionedOutputV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        inputs: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<TPUPartitionedOutputV2Inst> {
        let op = scope.new_operation("TPUPartitionedOutputV2", |builder| {
            builder.add_input(inputs);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_splits {
                builder.set_attr_int("num_splits", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.partition_dims {
                builder.set_attr_int_list("partition_dims", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(TPUPartitionedOutputV2Inst { op })
    }
}
impl TPUPartitionedOutputV2Inst {
    /// Returns a Vector of output for 'output' Output of this TPUPartitionedOutputV2 operation.
    pub fn output(&self) -> crate::Result<Vec<crate::Output>> {
        let mut Outputs = vec![];
        for i in 0..self.op.get_attr_int("num_splits")? as i32 {
            Outputs.push(crate::Output {
                operation: self.op.clone(),
                index: i,
            });
        }
        Ok(Outputs)
    }
    /// Returns the 'inputs' Input of this 'TPUPartitionedOutputV2' operation.
    pub fn inputs(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<TPUPartitionedOutputV2Inst> for crate::Operation {
    fn from(inst: TPUPartitionedOutputV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `TPUPartitionedOutputV2::new().build(inputs, scope)`.
pub fn tpupartitioned_output_v2<O0: ::std::convert::Into<crate::Output>>(
    inputs: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    TPUPartitionedOutputV2::new().build(inputs, scope)
}

/// Builder for the `TPUReplicateMetadata` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct TPUReplicateMetadata {
    num_replicas: ::std::option::Option<i64>,
    num_cores_per_replica: ::std::option::Option<i64>,
    topology: ::std::option::Option<::std::string::String>,
    use_tpu: ::std::option::Option<bool>,
    device_assignment: ::std::option::Option<::std::vec::Vec<i64>>,
    computation_shape: ::std::option::Option<::std::vec::Vec<i64>>,
    host_compute_core: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
    padding_map: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
    step_marker_location: ::std::option::Option<::std::string::String>,
    allow_soft_placement: ::std::option::Option<bool>,
    use_spmd_for_xla_partitioning: ::std::option::Option<bool>,
    tpu_compile_options_proto: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'TPUReplicateMetadata' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct TPUReplicateMetadataInst {
    /// An instance of a fully built TPUReplicateMetadata Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl TPUReplicateMetadata {
    /// Creates a new `TPUReplicateMetadata`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `num_replicas` attribute.
    pub fn num_replicas<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.num_replicas = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `num_cores_per_replica` attribute.
    pub fn num_cores_per_replica<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.num_cores_per_replica = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `topology` attribute.
    pub fn topology<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.topology = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_tpu` attribute.
    pub fn use_tpu<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.use_tpu = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `device_assignment` attribute.
    pub fn device_assignment<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.device_assignment = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `computation_shape` attribute.
    pub fn computation_shape<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.computation_shape = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `host_compute_core` attribute.
    pub fn host_compute_core<
        ArgType: ::std::convert::Into<::std::vec::Vec<::std::string::String>>,
    >(
        mut self,
        value: ArgType,
    ) -> Self {
        self.host_compute_core = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `padding_map` attribute.
    pub fn padding_map<ArgType: ::std::convert::Into<::std::vec::Vec<::std::string::String>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.padding_map = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `step_marker_location` attribute.
    pub fn step_marker_location<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.step_marker_location = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `allow_soft_placement` attribute.
    pub fn allow_soft_placement<ArgType: ::std::convert::Into<bool>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.allow_soft_placement = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `use_spmd_for_xla_partitioning` attribute.
    pub fn use_spmd_for_xla_partitioning<ArgType: ::std::convert::Into<bool>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.use_spmd_for_xla_partitioning = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `tpu_compile_options_proto` attribute.
    pub fn tpu_compile_options_proto<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.tpu_compile_options_proto = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `TPUReplicateMetadata` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("TPUReplicateMetadata", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.num_replicas {
                nd.set_attr_int("num_replicas", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_cores_per_replica {
                nd.set_attr_int("num_cores_per_replica", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.topology {
                nd.set_attr_string("topology", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_tpu {
                nd.set_attr_bool("use_tpu", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.device_assignment {
                nd.set_attr_int_list("device_assignment", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.computation_shape {
                nd.set_attr_int_list("computation_shape", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.host_compute_core {
                nd.set_attr_string_list("host_compute_core", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding_map {
                nd.set_attr_string_list("padding_map", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.step_marker_location {
                nd.set_attr_string("step_marker_location", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.allow_soft_placement {
                nd.set_attr_bool("allow_soft_placement", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_spmd_for_xla_partitioning {
                nd.set_attr_bool("use_spmd_for_xla_partitioning", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.tpu_compile_options_proto {
                nd.set_attr_string("tpu_compile_options_proto", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'TPUReplicateMetadata' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        scope: &mut crate::Scope,
    ) -> crate::Result<TPUReplicateMetadataInst> {
        let op = scope.new_operation("TPUReplicateMetadata", |builder| {
            if let ::std::option::Option::Some(value) = &self.num_replicas {
                builder.set_attr_int("num_replicas", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_cores_per_replica {
                builder.set_attr_int("num_cores_per_replica", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.topology {
                builder.set_attr_string("topology", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_tpu {
                builder.set_attr_bool("use_tpu", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.device_assignment {
                builder.set_attr_int_list("device_assignment", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.computation_shape {
                builder.set_attr_int_list("computation_shape", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.host_compute_core {
                builder.set_attr_string_list("host_compute_core", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding_map {
                builder.set_attr_string_list("padding_map", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.step_marker_location {
                builder.set_attr_string("step_marker_location", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.allow_soft_placement {
                builder.set_attr_bool("allow_soft_placement", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.use_spmd_for_xla_partitioning {
                builder.set_attr_bool("use_spmd_for_xla_partitioning", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.tpu_compile_options_proto {
                builder.set_attr_string("tpu_compile_options_proto", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(TPUReplicateMetadataInst { op })
    }
}
impl TPUReplicateMetadataInst {}
impl From<TPUReplicateMetadataInst> for crate::Operation {
    fn from(inst: TPUReplicateMetadataInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `TPUReplicateMetadata::new().build(scope)`.
pub fn tpureplicate_metadata(scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
    TPUReplicateMetadata::new().build(scope)
}

/// Builder for the `TPUReplicatedInput` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct TPUReplicatedInput {
    N: ::std::option::Option<i64>,
    T: ::std::option::Option<crate::DataType>,
    is_mirrored_variable: ::std::option::Option<bool>,
    index: ::std::option::Option<i64>,
    is_packed: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'TPUReplicatedInput' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct TPUReplicatedInputInst {
    /// An instance of a fully built TPUReplicatedInput Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl TPUReplicatedInput {
    /// Creates a new `TPUReplicatedInput`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `N` attribute.
    pub fn N<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.N = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `is_mirrored_variable` attribute.
    pub fn is_mirrored_variable<ArgType: ::std::convert::Into<bool>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.is_mirrored_variable = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `index` attribute.
    pub fn index<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.index = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `is_packed` attribute.
    pub fn is_packed<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.is_packed = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `TPUReplicatedInput` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        inputs: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(inputs.into(), scope)
    }
    fn build_impl(
        &self,
        inputs: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("TPUReplicatedInput", |nd| {
            nd.add_input(inputs);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.N {
                nd.set_attr_int("N", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.is_mirrored_variable {
                nd.set_attr_bool("is_mirrored_variable", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.index {
                nd.set_attr_int("index", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.is_packed {
                nd.set_attr_bool("is_packed", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'TPUReplicatedInput' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        inputs: Vec<crate::Output>,
        scope: &mut crate::Scope,
    ) -> crate::Result<TPUReplicatedInputInst> {
        let op = scope.new_operation("TPUReplicatedInput", |builder| {
            builder.add_input_list(&inputs);
            builder.set_attr_int("N", inputs.clone().len() as i64)?;
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.is_mirrored_variable {
                builder.set_attr_bool("is_mirrored_variable", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.index {
                builder.set_attr_int("index", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.is_packed {
                builder.set_attr_bool("is_packed", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(TPUReplicatedInputInst { op })
    }
}
impl TPUReplicatedInputInst {
    /// Returns the 'output' Output of this 'TPUReplicatedInput' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns a Vector of inputs for 'inputs' Input of this TPUReplicatedInput operation.
    pub fn inputs(&self) -> crate::Result<Vec<crate::Input>> {
        let mut Inputs = vec![];
        for i in 0..self.op.get_attr_int("N")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
}
impl From<TPUReplicatedInputInst> for crate::Operation {
    fn from(inst: TPUReplicatedInputInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `TPUReplicatedInput::new().build(inputs, scope)`.
pub fn tpureplicated_input<O0: ::std::convert::Into<crate::Output>>(
    inputs: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    TPUReplicatedInput::new().build(inputs, scope)
}

/// Builder for the `TPUReplicatedOutput` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct TPUReplicatedOutput {
    num_replicas: ::std::option::Option<i64>,
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'TPUReplicatedOutput' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct TPUReplicatedOutputInst {
    /// An instance of a fully built TPUReplicatedOutput Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl TPUReplicatedOutput {
    /// Creates a new `TPUReplicatedOutput`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `num_replicas` attribute.
    pub fn num_replicas<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.num_replicas = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `TPUReplicatedOutput` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("TPUReplicatedOutput", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.num_replicas {
                nd.set_attr_int("num_replicas", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'TPUReplicatedOutput' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<TPUReplicatedOutputInst> {
        let op = scope.new_operation("TPUReplicatedOutput", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.num_replicas {
                builder.set_attr_int("num_replicas", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(TPUReplicatedOutputInst { op })
    }
}
impl TPUReplicatedOutputInst {
    /// Returns a Vector of outputs for 'outputs' Output of this TPUReplicatedOutput operation.
    pub fn outputs(&self) -> crate::Result<Vec<crate::Output>> {
        let mut Outputs = vec![];
        for i in 0..self.op.get_attr_int("num_replicas")? as i32 {
            Outputs.push(crate::Output {
                operation: self.op.clone(),
                index: i,
            });
        }
        Ok(Outputs)
    }
    /// Returns the 'input' Input of this 'TPUReplicatedOutput' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<TPUReplicatedOutputInst> for crate::Operation {
    fn from(inst: TPUReplicatedOutputInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `TPUReplicatedOutput::new().build(input, scope)`.
pub fn tpureplicated_output<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    TPUReplicatedOutput::new().build(input, scope)
}

/// Builder for the `TPUReshardVariables` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct TPUReshardVariables {
    N: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'TPUReshardVariables' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct TPUReshardVariablesInst {
    /// An instance of a fully built TPUReshardVariables Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl TPUReshardVariables {
    /// Creates a new `TPUReshardVariables`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `N` attribute.
    pub fn N<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.N = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `TPUReshardVariables` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        vars: O0,
        new_format_key: O1,
        format_state_var: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            vars.into(),
            new_format_key.into(),
            format_state_var.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        vars: crate::Output,
        new_format_key: crate::Output,
        format_state_var: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("TPUReshardVariables", |nd| {
            nd.add_input(vars);
            nd.add_input(new_format_key);
            nd.add_input(format_state_var);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.N {
                nd.set_attr_int("N", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'TPUReshardVariables' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        vars: Vec<crate::Output>,
        new_format_key: crate::Output,
        format_state_var: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<TPUReshardVariablesInst> {
        let op = scope.new_operation("TPUReshardVariables", |builder| {
            builder.add_input_list(&vars);
            builder.add_input(new_format_key);
            builder.add_input(format_state_var);
            builder.set_attr_int("N", vars.clone().len() as i64)?;
            ::std::result::Result::Ok(())
        })?;
        Ok(TPUReshardVariablesInst { op })
    }
}
impl TPUReshardVariablesInst {
    /// Returns a Vector of vars for 'vars' Input of this TPUReshardVariables operation.
    pub fn vars(&self) -> crate::Result<Vec<crate::Input>> {
        let mut Inputs = vec![];
        for i in 0..self.op.get_attr_int("N")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
    /// Returns the 'new_format_key' Input of this 'TPUReshardVariables' operation.
    pub fn new_format_key(&self) -> crate::Result<crate::Input> {
        let dynamic_offset = (self.op.get_attr_int("N")? + 1) as i32;
        Ok(crate::Input {
            operation: &self.op,
            index: dynamic_offset,
        })
    }
    /// Returns the 'format_state_var' Input of this 'TPUReshardVariables' operation.
    pub fn format_state_var(&self) -> crate::Result<crate::Input> {
        let dynamic_offset = (self.op.get_attr_int("N")? + 2) as i32;
        Ok(crate::Input {
            operation: &self.op,
            index: dynamic_offset,
        })
    }
}
impl From<TPUReshardVariablesInst> for crate::Operation {
    fn from(inst: TPUReshardVariablesInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `TPUReshardVariables::new().build(vars, new_format_key, format_state_var, scope)`.
pub fn tpureshard_variables<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    vars: O0,
    new_format_key: O1,
    format_state_var: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    TPUReshardVariables::new().build(vars, new_format_key, format_state_var, scope)
}

/// Builder for the `TPURoundRobin` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct TPURoundRobin {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'TPURoundRobin' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct TPURoundRobinInst {
    /// An instance of a fully built TPURoundRobin Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl TPURoundRobin {
    /// Creates a new `TPURoundRobin`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `TPURoundRobin` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("TPURoundRobin", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'TPURoundRobin' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(&self, scope: &mut crate::Scope) -> crate::Result<TPURoundRobinInst> {
        let op = scope.new_operation("TPURoundRobin", |builder| ::std::result::Result::Ok(()))?;
        Ok(TPURoundRobinInst { op })
    }
}
impl TPURoundRobinInst {
    /// Returns the 'device_ordinal' Output of this 'TPURoundRobin' operation.
    pub fn device_ordinal(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
}
impl From<TPURoundRobinInst> for crate::Operation {
    fn from(inst: TPURoundRobinInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `TPURoundRobin::new().build(scope)`.
pub fn tpuround_robin(scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
    TPURoundRobin::new().build(scope)
}

/// Builder for the `TakeDataset` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct TakeDataset {
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    metadata: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'TakeDataset' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct TakeDatasetInst {
    /// An instance of a fully built TakeDataset Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl TakeDataset {
    /// Creates a new `TakeDataset`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `metadata` attribute.
    pub fn metadata<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.metadata = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `TakeDataset` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input_dataset: O0,
        count: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input_dataset.into(), count.into(), scope)
    }
    fn build_impl(
        &self,
        input_dataset: crate::Output,
        count: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("TakeDataset", |nd| {
            nd.add_input(input_dataset);
            nd.add_input(count);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.metadata {
                nd.set_attr_string("metadata", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'TakeDataset' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_dataset: crate::Output,
        count: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<TakeDatasetInst> {
        let op = scope.new_operation("TakeDataset", |builder| {
            builder.add_input(input_dataset);
            builder.add_input(count);
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.metadata {
                builder.set_attr_string("metadata", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(TakeDatasetInst { op })
    }
}
impl TakeDatasetInst {
    /// Returns the 'handle' Output of this 'TakeDataset' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_dataset' Input of this 'TakeDataset' operation.
    pub fn input_dataset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'count' Input of this 'TakeDataset' operation.
    pub fn count(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<TakeDatasetInst> for crate::Operation {
    fn from(inst: TakeDatasetInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `TakeDataset::new().build(input_dataset, count, scope)`.
pub fn take_dataset<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    input_dataset: O0,
    count: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    TakeDataset::new().build(input_dataset, count, scope)
}

/// Builder for the `TakeManySparseFromTensorsMap` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct TakeManySparseFromTensorsMap {
    dtype: ::std::option::Option<crate::DataType>,
    container: ::std::option::Option<::std::string::String>,
    shared_name: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'TakeManySparseFromTensorsMap' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct TakeManySparseFromTensorsMapInst {
    /// An instance of a fully built TakeManySparseFromTensorsMap Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl TakeManySparseFromTensorsMap {
    /// Creates a new `TakeManySparseFromTensorsMap`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `dtype` attribute.
    pub fn dtype<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `container` attribute.
    pub fn container<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.container = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shared_name` attribute.
    pub fn shared_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.shared_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `TakeManySparseFromTensorsMap` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        sparse_handles: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(sparse_handles.into(), scope)
    }
    fn build_impl(
        &self,
        sparse_handles: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("TakeManySparseFromTensorsMap", |nd| {
            nd.add_input(sparse_handles);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                nd.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.container {
                nd.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                nd.set_attr_string("shared_name", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'TakeManySparseFromTensorsMap' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        sparse_handles: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<TakeManySparseFromTensorsMapInst> {
        let op = scope.new_operation("TakeManySparseFromTensorsMap", |builder| {
            builder.add_input(sparse_handles);
            if let ::std::option::Option::Some(value) = &self.dtype {
                builder.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.container {
                builder.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                builder.set_attr_string("shared_name", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(TakeManySparseFromTensorsMapInst { op })
    }
}
impl TakeManySparseFromTensorsMapInst {
    /// Returns the 'sparse_indices' Output of this 'TakeManySparseFromTensorsMap' operation.
    pub fn sparse_indices(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'sparse_values' Output of this 'TakeManySparseFromTensorsMap' operation.
    pub fn sparse_values(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'sparse_shape' Output of this 'TakeManySparseFromTensorsMap' operation.
    pub fn sparse_shape(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns the 'sparse_handles' Input of this 'TakeManySparseFromTensorsMap' operation.
    pub fn sparse_handles(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<TakeManySparseFromTensorsMapInst> for crate::Operation {
    fn from(inst: TakeManySparseFromTensorsMapInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `TakeManySparseFromTensorsMap::new().build(sparse_handles, scope)`.
pub fn take_many_sparse_from_tensors_map<O0: ::std::convert::Into<crate::Output>>(
    sparse_handles: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    TakeManySparseFromTensorsMap::new().build(sparse_handles, scope)
}

/// Builder for the `TakeWhileDataset` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct TakeWhileDataset {
    predicate: ::std::option::Option<::std::string::String>,
    Targuments: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    metadata: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'TakeWhileDataset' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct TakeWhileDatasetInst {
    /// An instance of a fully built TakeWhileDataset Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl TakeWhileDataset {
    /// Creates a new `TakeWhileDataset`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `predicate` attribute.
    pub fn predicate<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.predicate = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Targuments` attribute.
    pub fn Targuments<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Targuments = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `metadata` attribute.
    pub fn metadata<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.metadata = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `TakeWhileDataset` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input_dataset: O0,
        other_arguments: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input_dataset.into(), other_arguments.into(), scope)
    }
    fn build_impl(
        &self,
        input_dataset: crate::Output,
        other_arguments: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("TakeWhileDataset", |nd| {
            nd.add_input(input_dataset);
            nd.add_input(other_arguments);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.predicate {
                nd.set_attr_string("predicate", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Targuments {
                nd.set_attr_type_list("Targuments", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.metadata {
                nd.set_attr_string("metadata", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'TakeWhileDataset' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_dataset: crate::Output,
        other_arguments: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<TakeWhileDatasetInst> {
        let op = scope.new_operation("TakeWhileDataset", |builder| {
            builder.add_input(input_dataset);
            builder.add_input(other_arguments);
            if let ::std::option::Option::Some(value) = &self.predicate {
                builder.set_attr_string("predicate", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Targuments {
                builder.set_attr_type_list("Targuments", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.metadata {
                builder.set_attr_string("metadata", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(TakeWhileDatasetInst { op })
    }
}
impl TakeWhileDatasetInst {
    /// Returns the 'handle' Output of this 'TakeWhileDataset' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_dataset' Input of this 'TakeWhileDataset' operation.
    pub fn input_dataset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'other_arguments' Input of this 'TakeWhileDataset' operation.
    pub fn other_arguments(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<TakeWhileDatasetInst> for crate::Operation {
    fn from(inst: TakeWhileDatasetInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `TakeWhileDataset::new().build(input_dataset, other_arguments, scope)`.
pub fn take_while_dataset<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    input_dataset: O0,
    other_arguments: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    TakeWhileDataset::new().build(input_dataset, other_arguments, scope)
}

/// Builder for the `Tan` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Tan {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Tan' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct TanInst {
    /// An instance of a fully built Tan Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Tan {
    /// Creates a new `Tan`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Tan` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        x: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Tan", |nd| {
            nd.add_input(x);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Tan' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<TanInst> {
        let op = scope.new_operation("Tan", |builder| {
            builder.add_input(x);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(TanInst { op })
    }
}
impl TanInst {
    /// Returns the 'y' Output of this 'Tan' operation.
    pub fn y(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'Tan' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<TanInst> for crate::Operation {
    fn from(inst: TanInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Tan::new().build(x, scope)`.
pub fn tan<O0: ::std::convert::Into<crate::Output>>(
    x: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Tan::new().build(x, scope)
}

/// Builder for the `Tanh` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Tanh {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Tanh' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct TanhInst {
    /// An instance of a fully built Tanh Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Tanh {
    /// Creates a new `Tanh`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Tanh` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        x: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Tanh", |nd| {
            nd.add_input(x);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Tanh' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<TanhInst> {
        let op = scope.new_operation("Tanh", |builder| {
            builder.add_input(x);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(TanhInst { op })
    }
}
impl TanhInst {
    /// Returns the 'y' Output of this 'Tanh' operation.
    pub fn y(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'Tanh' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<TanhInst> for crate::Operation {
    fn from(inst: TanhInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Tanh::new().build(x, scope)`.
pub fn tanh<O0: ::std::convert::Into<crate::Output>>(
    x: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Tanh::new().build(x, scope)
}

/// Builder for the `TanhGrad` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct TanhGrad {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'TanhGrad' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct TanhGradInst {
    /// An instance of a fully built TanhGrad Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl TanhGrad {
    /// Creates a new `TanhGrad`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `TanhGrad` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        y: O0,
        dy: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(y.into(), dy.into(), scope)
    }
    fn build_impl(
        &self,
        y: crate::Output,
        dy: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("TanhGrad", |nd| {
            nd.add_input(y);
            nd.add_input(dy);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'TanhGrad' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        y: crate::Output,
        dy: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<TanhGradInst> {
        let op = scope.new_operation("TanhGrad", |builder| {
            builder.add_input(y);
            builder.add_input(dy);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(TanhGradInst { op })
    }
}
impl TanhGradInst {
    /// Returns the 'z' Output of this 'TanhGrad' operation.
    pub fn z(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'y' Input of this 'TanhGrad' operation.
    pub fn y(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'dy' Input of this 'TanhGrad' operation.
    pub fn dy(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<TanhGradInst> for crate::Operation {
    fn from(inst: TanhGradInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `TanhGrad::new().build(y, dy, scope)`.
pub fn tanh_grad<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    y: O0,
    dy: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    TanhGrad::new().build(y, dy, scope)
}

/// Builder for the `TemporaryVariable` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct TemporaryVariable {
    shape: ::std::option::Option<crate::Shape>,
    dtype: ::std::option::Option<crate::DataType>,
    var_name: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'TemporaryVariable' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct TemporaryVariableInst {
    /// An instance of a fully built TemporaryVariable Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl TemporaryVariable {
    /// Creates a new `TemporaryVariable`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `shape` attribute.
    pub fn shape<ArgType: ::std::convert::Into<crate::Shape>>(mut self, value: ArgType) -> Self {
        self.shape = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `dtype` attribute.
    pub fn dtype<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `var_name` attribute.
    pub fn var_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.var_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `TemporaryVariable` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("TemporaryVariable", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.shape {
                nd.set_attr_shape("shape", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                nd.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.var_name {
                nd.set_attr_string("var_name", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'TemporaryVariable' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(&self, scope: &mut crate::Scope) -> crate::Result<TemporaryVariableInst> {
        let op = scope.new_operation("TemporaryVariable", |builder| {
            if let ::std::option::Option::Some(value) = &self.shape {
                builder.set_attr_shape("shape", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                builder.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.var_name {
                builder.set_attr_string("var_name", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(TemporaryVariableInst { op })
    }
}
impl TemporaryVariableInst {
    /// Returns the 'ref_' Output of this 'TemporaryVariable' operation.
    pub fn ref_(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
}
impl From<TemporaryVariableInst> for crate::Operation {
    fn from(inst: TemporaryVariableInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `TemporaryVariable::new().build(scope)`.
pub fn temporary_variable(scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
    TemporaryVariable::new().build(scope)
}

/// Builder for the `TensorArray` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct TensorArray {
    dtype: ::std::option::Option<crate::DataType>,
    dynamic_size: ::std::option::Option<bool>,
    clear_after_read: ::std::option::Option<bool>,
    tensor_array_name: ::std::option::Option<::std::string::String>,
    element_shape: ::std::option::Option<crate::Shape>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'TensorArray' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct TensorArrayInst {
    /// An instance of a fully built TensorArray Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl TensorArray {
    /// Creates a new `TensorArray`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `dtype` attribute.
    pub fn dtype<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `dynamic_size` attribute.
    pub fn dynamic_size<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.dynamic_size = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `clear_after_read` attribute.
    pub fn clear_after_read<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.clear_after_read = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `tensor_array_name` attribute.
    pub fn tensor_array_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.tensor_array_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `element_shape` attribute.
    pub fn element_shape<ArgType: ::std::convert::Into<crate::Shape>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.element_shape = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `TensorArray` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        size: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(size.into(), scope)
    }
    fn build_impl(
        &self,
        size: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("TensorArray", |nd| {
            nd.add_input(size);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                nd.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dynamic_size {
                nd.set_attr_bool("dynamic_size", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.clear_after_read {
                nd.set_attr_bool("clear_after_read", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.tensor_array_name {
                nd.set_attr_string("tensor_array_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.element_shape {
                nd.set_attr_shape("element_shape", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'TensorArray' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        size: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<TensorArrayInst> {
        let op = scope.new_operation("TensorArray", |builder| {
            builder.add_input(size);
            if let ::std::option::Option::Some(value) = &self.dtype {
                builder.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dynamic_size {
                builder.set_attr_bool("dynamic_size", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.clear_after_read {
                builder.set_attr_bool("clear_after_read", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.tensor_array_name {
                builder.set_attr_string("tensor_array_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.element_shape {
                builder.set_attr_shape("element_shape", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(TensorArrayInst { op })
    }
}
impl TensorArrayInst {
    /// Returns the 'handle' Output of this 'TensorArray' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'size' Input of this 'TensorArray' operation.
    pub fn size(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<TensorArrayInst> for crate::Operation {
    fn from(inst: TensorArrayInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `TensorArray::new().build(size, scope)`.
pub fn tensor_array<O0: ::std::convert::Into<crate::Output>>(
    size: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    TensorArray::new().build(size, scope)
}

/// Builder for the `TensorArrayClose` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct TensorArrayClose {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'TensorArrayClose' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct TensorArrayCloseInst {
    /// An instance of a fully built TensorArrayClose Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl TensorArrayClose {
    /// Creates a new `TensorArrayClose`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `TensorArrayClose` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        handle: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(handle.into(), scope)
    }
    fn build_impl(
        &self,
        handle: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("TensorArrayClose", |nd| {
            nd.add_input(handle);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'TensorArrayClose' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        handle: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<TensorArrayCloseInst> {
        let op = scope.new_operation("TensorArrayClose", |builder| {
            builder.add_input(handle);
            ::std::result::Result::Ok(())
        })?;
        Ok(TensorArrayCloseInst { op })
    }
}
impl TensorArrayCloseInst {
    /// Returns the 'handle' Input of this 'TensorArrayClose' operation.
    pub fn handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<TensorArrayCloseInst> for crate::Operation {
    fn from(inst: TensorArrayCloseInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `TensorArrayClose::new().build(handle, scope)`.
pub fn tensor_array_close<O0: ::std::convert::Into<crate::Output>>(
    handle: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    TensorArrayClose::new().build(handle, scope)
}

/// Builder for the `TensorArrayCloseV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct TensorArrayCloseV2 {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'TensorArrayCloseV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct TensorArrayCloseV2Inst {
    /// An instance of a fully built TensorArrayCloseV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl TensorArrayCloseV2 {
    /// Creates a new `TensorArrayCloseV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `TensorArrayCloseV2` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        handle: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(handle.into(), scope)
    }
    fn build_impl(
        &self,
        handle: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("TensorArrayCloseV2", |nd| {
            nd.add_input(handle);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'TensorArrayCloseV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        handle: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<TensorArrayCloseV2Inst> {
        let op = scope.new_operation("TensorArrayCloseV2", |builder| {
            builder.add_input(handle);
            ::std::result::Result::Ok(())
        })?;
        Ok(TensorArrayCloseV2Inst { op })
    }
}
impl TensorArrayCloseV2Inst {
    /// Returns the 'handle' Input of this 'TensorArrayCloseV2' operation.
    pub fn handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<TensorArrayCloseV2Inst> for crate::Operation {
    fn from(inst: TensorArrayCloseV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `TensorArrayCloseV2::new().build(handle, scope)`.
pub fn tensor_array_close_v2<O0: ::std::convert::Into<crate::Output>>(
    handle: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    TensorArrayCloseV2::new().build(handle, scope)
}

/// Builder for the `TensorArrayCloseV3` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct TensorArrayCloseV3 {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'TensorArrayCloseV3' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct TensorArrayCloseV3Inst {
    /// An instance of a fully built TensorArrayCloseV3 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl TensorArrayCloseV3 {
    /// Creates a new `TensorArrayCloseV3`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `TensorArrayCloseV3` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        handle: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(handle.into(), scope)
    }
    fn build_impl(
        &self,
        handle: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("TensorArrayCloseV3", |nd| {
            nd.add_input(handle);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'TensorArrayCloseV3' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        handle: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<TensorArrayCloseV3Inst> {
        let op = scope.new_operation("TensorArrayCloseV3", |builder| {
            builder.add_input(handle);
            ::std::result::Result::Ok(())
        })?;
        Ok(TensorArrayCloseV3Inst { op })
    }
}
impl TensorArrayCloseV3Inst {
    /// Returns the 'handle' Input of this 'TensorArrayCloseV3' operation.
    pub fn handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<TensorArrayCloseV3Inst> for crate::Operation {
    fn from(inst: TensorArrayCloseV3Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `TensorArrayCloseV3::new().build(handle, scope)`.
pub fn tensor_array_close_v3<O0: ::std::convert::Into<crate::Output>>(
    handle: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    TensorArrayCloseV3::new().build(handle, scope)
}

/// Builder for the `TensorArrayConcat` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct TensorArrayConcat {
    dtype: ::std::option::Option<crate::DataType>,
    element_shape_except0: ::std::option::Option<crate::Shape>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'TensorArrayConcat' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct TensorArrayConcatInst {
    /// An instance of a fully built TensorArrayConcat Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl TensorArrayConcat {
    /// Creates a new `TensorArrayConcat`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `dtype` attribute.
    pub fn dtype<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `element_shape_except0` attribute.
    pub fn element_shape_except0<ArgType: ::std::convert::Into<crate::Shape>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.element_shape_except0 = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `TensorArrayConcat` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        handle: O0,
        flow_in: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(handle.into(), flow_in.into(), scope)
    }
    fn build_impl(
        &self,
        handle: crate::Output,
        flow_in: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("TensorArrayConcat", |nd| {
            nd.add_input(handle);
            nd.add_input(flow_in);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                nd.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.element_shape_except0 {
                nd.set_attr_shape("element_shape_except0", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'TensorArrayConcat' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        handle: crate::Output,
        flow_in: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<TensorArrayConcatInst> {
        let op = scope.new_operation("TensorArrayConcat", |builder| {
            builder.add_input(handle);
            builder.add_input(flow_in);
            if let ::std::option::Option::Some(value) = &self.dtype {
                builder.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.element_shape_except0 {
                builder.set_attr_shape("element_shape_except0", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(TensorArrayConcatInst { op })
    }
}
impl TensorArrayConcatInst {
    /// Returns the 'value' Output of this 'TensorArrayConcat' operation.
    pub fn value(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'lengths' Output of this 'TensorArrayConcat' operation.
    pub fn lengths(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'handle' Input of this 'TensorArrayConcat' operation.
    pub fn handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'flow_in' Input of this 'TensorArrayConcat' operation.
    pub fn flow_in(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<TensorArrayConcatInst> for crate::Operation {
    fn from(inst: TensorArrayConcatInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `TensorArrayConcat::new().build(handle, flow_in, scope)`.
pub fn tensor_array_concat<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    handle: O0,
    flow_in: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    TensorArrayConcat::new().build(handle, flow_in, scope)
}

/// Builder for the `TensorArrayConcatV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct TensorArrayConcatV2 {
    dtype: ::std::option::Option<crate::DataType>,
    element_shape_except0: ::std::option::Option<crate::Shape>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'TensorArrayConcatV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct TensorArrayConcatV2Inst {
    /// An instance of a fully built TensorArrayConcatV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl TensorArrayConcatV2 {
    /// Creates a new `TensorArrayConcatV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `dtype` attribute.
    pub fn dtype<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `element_shape_except0` attribute.
    pub fn element_shape_except0<ArgType: ::std::convert::Into<crate::Shape>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.element_shape_except0 = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `TensorArrayConcatV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        handle: O0,
        flow_in: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(handle.into(), flow_in.into(), scope)
    }
    fn build_impl(
        &self,
        handle: crate::Output,
        flow_in: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("TensorArrayConcatV2", |nd| {
            nd.add_input(handle);
            nd.add_input(flow_in);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                nd.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.element_shape_except0 {
                nd.set_attr_shape("element_shape_except0", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'TensorArrayConcatV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        handle: crate::Output,
        flow_in: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<TensorArrayConcatV2Inst> {
        let op = scope.new_operation("TensorArrayConcatV2", |builder| {
            builder.add_input(handle);
            builder.add_input(flow_in);
            if let ::std::option::Option::Some(value) = &self.dtype {
                builder.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.element_shape_except0 {
                builder.set_attr_shape("element_shape_except0", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(TensorArrayConcatV2Inst { op })
    }
}
impl TensorArrayConcatV2Inst {
    /// Returns the 'value' Output of this 'TensorArrayConcatV2' operation.
    pub fn value(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'lengths' Output of this 'TensorArrayConcatV2' operation.
    pub fn lengths(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'handle' Input of this 'TensorArrayConcatV2' operation.
    pub fn handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'flow_in' Input of this 'TensorArrayConcatV2' operation.
    pub fn flow_in(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<TensorArrayConcatV2Inst> for crate::Operation {
    fn from(inst: TensorArrayConcatV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `TensorArrayConcatV2::new().build(handle, flow_in, scope)`.
pub fn tensor_array_concat_v2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    handle: O0,
    flow_in: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    TensorArrayConcatV2::new().build(handle, flow_in, scope)
}

/// Builder for the `TensorArrayConcatV3` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct TensorArrayConcatV3 {
    dtype: ::std::option::Option<crate::DataType>,
    element_shape_except0: ::std::option::Option<crate::Shape>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'TensorArrayConcatV3' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct TensorArrayConcatV3Inst {
    /// An instance of a fully built TensorArrayConcatV3 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl TensorArrayConcatV3 {
    /// Creates a new `TensorArrayConcatV3`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `dtype` attribute.
    pub fn dtype<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `element_shape_except0` attribute.
    pub fn element_shape_except0<ArgType: ::std::convert::Into<crate::Shape>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.element_shape_except0 = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `TensorArrayConcatV3` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        handle: O0,
        flow_in: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(handle.into(), flow_in.into(), scope)
    }
    fn build_impl(
        &self,
        handle: crate::Output,
        flow_in: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("TensorArrayConcatV3", |nd| {
            nd.add_input(handle);
            nd.add_input(flow_in);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                nd.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.element_shape_except0 {
                nd.set_attr_shape("element_shape_except0", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'TensorArrayConcatV3' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        handle: crate::Output,
        flow_in: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<TensorArrayConcatV3Inst> {
        let op = scope.new_operation("TensorArrayConcatV3", |builder| {
            builder.add_input(handle);
            builder.add_input(flow_in);
            if let ::std::option::Option::Some(value) = &self.dtype {
                builder.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.element_shape_except0 {
                builder.set_attr_shape("element_shape_except0", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(TensorArrayConcatV3Inst { op })
    }
}
impl TensorArrayConcatV3Inst {
    /// Returns the 'value' Output of this 'TensorArrayConcatV3' operation.
    pub fn value(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'lengths' Output of this 'TensorArrayConcatV3' operation.
    pub fn lengths(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'handle' Input of this 'TensorArrayConcatV3' operation.
    pub fn handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'flow_in' Input of this 'TensorArrayConcatV3' operation.
    pub fn flow_in(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<TensorArrayConcatV3Inst> for crate::Operation {
    fn from(inst: TensorArrayConcatV3Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `TensorArrayConcatV3::new().build(handle, flow_in, scope)`.
pub fn tensor_array_concat_v3<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    handle: O0,
    flow_in: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    TensorArrayConcatV3::new().build(handle, flow_in, scope)
}

/// Builder for the `TensorArrayGather` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct TensorArrayGather {
    dtype: ::std::option::Option<crate::DataType>,
    element_shape: ::std::option::Option<crate::Shape>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'TensorArrayGather' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct TensorArrayGatherInst {
    /// An instance of a fully built TensorArrayGather Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl TensorArrayGather {
    /// Creates a new `TensorArrayGather`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `dtype` attribute.
    pub fn dtype<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `element_shape` attribute.
    pub fn element_shape<ArgType: ::std::convert::Into<crate::Shape>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.element_shape = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `TensorArrayGather` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        handle: O0,
        indices: O1,
        flow_in: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(handle.into(), indices.into(), flow_in.into(), scope)
    }
    fn build_impl(
        &self,
        handle: crate::Output,
        indices: crate::Output,
        flow_in: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("TensorArrayGather", |nd| {
            nd.add_input(handle);
            nd.add_input(indices);
            nd.add_input(flow_in);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                nd.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.element_shape {
                nd.set_attr_shape("element_shape", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'TensorArrayGather' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        handle: crate::Output,
        indices: crate::Output,
        flow_in: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<TensorArrayGatherInst> {
        let op = scope.new_operation("TensorArrayGather", |builder| {
            builder.add_input(handle);
            builder.add_input(indices);
            builder.add_input(flow_in);
            if let ::std::option::Option::Some(value) = &self.dtype {
                builder.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.element_shape {
                builder.set_attr_shape("element_shape", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(TensorArrayGatherInst { op })
    }
}
impl TensorArrayGatherInst {
    /// Returns the 'value' Output of this 'TensorArrayGather' operation.
    pub fn value(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'handle' Input of this 'TensorArrayGather' operation.
    pub fn handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'indices' Input of this 'TensorArrayGather' operation.
    pub fn indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'flow_in' Input of this 'TensorArrayGather' operation.
    pub fn flow_in(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<TensorArrayGatherInst> for crate::Operation {
    fn from(inst: TensorArrayGatherInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `TensorArrayGather::new().build(handle, indices, flow_in, scope)`.
pub fn tensor_array_gather<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    handle: O0,
    indices: O1,
    flow_in: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    TensorArrayGather::new().build(handle, indices, flow_in, scope)
}

/// Builder for the `TensorArrayGatherV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct TensorArrayGatherV2 {
    dtype: ::std::option::Option<crate::DataType>,
    element_shape: ::std::option::Option<crate::Shape>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'TensorArrayGatherV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct TensorArrayGatherV2Inst {
    /// An instance of a fully built TensorArrayGatherV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl TensorArrayGatherV2 {
    /// Creates a new `TensorArrayGatherV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `dtype` attribute.
    pub fn dtype<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `element_shape` attribute.
    pub fn element_shape<ArgType: ::std::convert::Into<crate::Shape>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.element_shape = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `TensorArrayGatherV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        handle: O0,
        indices: O1,
        flow_in: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(handle.into(), indices.into(), flow_in.into(), scope)
    }
    fn build_impl(
        &self,
        handle: crate::Output,
        indices: crate::Output,
        flow_in: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("TensorArrayGatherV2", |nd| {
            nd.add_input(handle);
            nd.add_input(indices);
            nd.add_input(flow_in);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                nd.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.element_shape {
                nd.set_attr_shape("element_shape", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'TensorArrayGatherV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        handle: crate::Output,
        indices: crate::Output,
        flow_in: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<TensorArrayGatherV2Inst> {
        let op = scope.new_operation("TensorArrayGatherV2", |builder| {
            builder.add_input(handle);
            builder.add_input(indices);
            builder.add_input(flow_in);
            if let ::std::option::Option::Some(value) = &self.dtype {
                builder.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.element_shape {
                builder.set_attr_shape("element_shape", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(TensorArrayGatherV2Inst { op })
    }
}
impl TensorArrayGatherV2Inst {
    /// Returns the 'value' Output of this 'TensorArrayGatherV2' operation.
    pub fn value(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'handle' Input of this 'TensorArrayGatherV2' operation.
    pub fn handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'indices' Input of this 'TensorArrayGatherV2' operation.
    pub fn indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'flow_in' Input of this 'TensorArrayGatherV2' operation.
    pub fn flow_in(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<TensorArrayGatherV2Inst> for crate::Operation {
    fn from(inst: TensorArrayGatherV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `TensorArrayGatherV2::new().build(handle, indices, flow_in, scope)`.
pub fn tensor_array_gather_v2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    handle: O0,
    indices: O1,
    flow_in: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    TensorArrayGatherV2::new().build(handle, indices, flow_in, scope)
}

/// Builder for the `TensorArrayGatherV3` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct TensorArrayGatherV3 {
    dtype: ::std::option::Option<crate::DataType>,
    element_shape: ::std::option::Option<crate::Shape>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'TensorArrayGatherV3' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct TensorArrayGatherV3Inst {
    /// An instance of a fully built TensorArrayGatherV3 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl TensorArrayGatherV3 {
    /// Creates a new `TensorArrayGatherV3`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `dtype` attribute.
    pub fn dtype<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `element_shape` attribute.
    pub fn element_shape<ArgType: ::std::convert::Into<crate::Shape>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.element_shape = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `TensorArrayGatherV3` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        handle: O0,
        indices: O1,
        flow_in: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(handle.into(), indices.into(), flow_in.into(), scope)
    }
    fn build_impl(
        &self,
        handle: crate::Output,
        indices: crate::Output,
        flow_in: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("TensorArrayGatherV3", |nd| {
            nd.add_input(handle);
            nd.add_input(indices);
            nd.add_input(flow_in);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                nd.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.element_shape {
                nd.set_attr_shape("element_shape", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'TensorArrayGatherV3' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        handle: crate::Output,
        indices: crate::Output,
        flow_in: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<TensorArrayGatherV3Inst> {
        let op = scope.new_operation("TensorArrayGatherV3", |builder| {
            builder.add_input(handle);
            builder.add_input(indices);
            builder.add_input(flow_in);
            if let ::std::option::Option::Some(value) = &self.dtype {
                builder.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.element_shape {
                builder.set_attr_shape("element_shape", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(TensorArrayGatherV3Inst { op })
    }
}
impl TensorArrayGatherV3Inst {
    /// Returns the 'value' Output of this 'TensorArrayGatherV3' operation.
    pub fn value(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'handle' Input of this 'TensorArrayGatherV3' operation.
    pub fn handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'indices' Input of this 'TensorArrayGatherV3' operation.
    pub fn indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'flow_in' Input of this 'TensorArrayGatherV3' operation.
    pub fn flow_in(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<TensorArrayGatherV3Inst> for crate::Operation {
    fn from(inst: TensorArrayGatherV3Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `TensorArrayGatherV3::new().build(handle, indices, flow_in, scope)`.
pub fn tensor_array_gather_v3<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    handle: O0,
    indices: O1,
    flow_in: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    TensorArrayGatherV3::new().build(handle, indices, flow_in, scope)
}

/// Builder for the `TensorArrayGrad` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct TensorArrayGrad {
    source: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'TensorArrayGrad' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct TensorArrayGradInst {
    /// An instance of a fully built TensorArrayGrad Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl TensorArrayGrad {
    /// Creates a new `TensorArrayGrad`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `source` attribute.
    pub fn source<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.source = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `TensorArrayGrad` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        handle: O0,
        flow_in: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(handle.into(), flow_in.into(), scope)
    }
    fn build_impl(
        &self,
        handle: crate::Output,
        flow_in: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("TensorArrayGrad", |nd| {
            nd.add_input(handle);
            nd.add_input(flow_in);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.source {
                nd.set_attr_string("source", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'TensorArrayGrad' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        handle: crate::Output,
        flow_in: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<TensorArrayGradInst> {
        let op = scope.new_operation("TensorArrayGrad", |builder| {
            builder.add_input(handle);
            builder.add_input(flow_in);
            if let ::std::option::Option::Some(value) = &self.source {
                builder.set_attr_string("source", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(TensorArrayGradInst { op })
    }
}
impl TensorArrayGradInst {
    /// Returns the 'grad_handle' Output of this 'TensorArrayGrad' operation.
    pub fn grad_handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'handle' Input of this 'TensorArrayGrad' operation.
    pub fn handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'flow_in' Input of this 'TensorArrayGrad' operation.
    pub fn flow_in(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<TensorArrayGradInst> for crate::Operation {
    fn from(inst: TensorArrayGradInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `TensorArrayGrad::new().build(handle, flow_in, scope)`.
pub fn tensor_array_grad<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    handle: O0,
    flow_in: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    TensorArrayGrad::new().build(handle, flow_in, scope)
}

/// Builder for the `TensorArrayGradV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct TensorArrayGradV2 {
    source: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'TensorArrayGradV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct TensorArrayGradV2Inst {
    /// An instance of a fully built TensorArrayGradV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl TensorArrayGradV2 {
    /// Creates a new `TensorArrayGradV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `source` attribute.
    pub fn source<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.source = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `TensorArrayGradV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        handle: O0,
        flow_in: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(handle.into(), flow_in.into(), scope)
    }
    fn build_impl(
        &self,
        handle: crate::Output,
        flow_in: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("TensorArrayGradV2", |nd| {
            nd.add_input(handle);
            nd.add_input(flow_in);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.source {
                nd.set_attr_string("source", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'TensorArrayGradV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        handle: crate::Output,
        flow_in: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<TensorArrayGradV2Inst> {
        let op = scope.new_operation("TensorArrayGradV2", |builder| {
            builder.add_input(handle);
            builder.add_input(flow_in);
            if let ::std::option::Option::Some(value) = &self.source {
                builder.set_attr_string("source", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(TensorArrayGradV2Inst { op })
    }
}
impl TensorArrayGradV2Inst {
    /// Returns the 'grad_handle' Output of this 'TensorArrayGradV2' operation.
    pub fn grad_handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'handle' Input of this 'TensorArrayGradV2' operation.
    pub fn handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'flow_in' Input of this 'TensorArrayGradV2' operation.
    pub fn flow_in(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<TensorArrayGradV2Inst> for crate::Operation {
    fn from(inst: TensorArrayGradV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `TensorArrayGradV2::new().build(handle, flow_in, scope)`.
pub fn tensor_array_grad_v2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    handle: O0,
    flow_in: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    TensorArrayGradV2::new().build(handle, flow_in, scope)
}

/// Builder for the `TensorArrayGradV3` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct TensorArrayGradV3 {
    source: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'TensorArrayGradV3' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct TensorArrayGradV3Inst {
    /// An instance of a fully built TensorArrayGradV3 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl TensorArrayGradV3 {
    /// Creates a new `TensorArrayGradV3`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `source` attribute.
    pub fn source<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.source = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `TensorArrayGradV3` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        handle: O0,
        flow_in: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(handle.into(), flow_in.into(), scope)
    }
    fn build_impl(
        &self,
        handle: crate::Output,
        flow_in: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("TensorArrayGradV3", |nd| {
            nd.add_input(handle);
            nd.add_input(flow_in);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.source {
                nd.set_attr_string("source", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'TensorArrayGradV3' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        handle: crate::Output,
        flow_in: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<TensorArrayGradV3Inst> {
        let op = scope.new_operation("TensorArrayGradV3", |builder| {
            builder.add_input(handle);
            builder.add_input(flow_in);
            if let ::std::option::Option::Some(value) = &self.source {
                builder.set_attr_string("source", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(TensorArrayGradV3Inst { op })
    }
}
impl TensorArrayGradV3Inst {
    /// Returns the 'grad_handle' Output of this 'TensorArrayGradV3' operation.
    pub fn grad_handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'flow_out' Output of this 'TensorArrayGradV3' operation.
    pub fn flow_out(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'handle' Input of this 'TensorArrayGradV3' operation.
    pub fn handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'flow_in' Input of this 'TensorArrayGradV3' operation.
    pub fn flow_in(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<TensorArrayGradV3Inst> for crate::Operation {
    fn from(inst: TensorArrayGradV3Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `TensorArrayGradV3::new().build(handle, flow_in, scope)`.
pub fn tensor_array_grad_v3<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    handle: O0,
    flow_in: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    TensorArrayGradV3::new().build(handle, flow_in, scope)
}

/// Builder for the `TensorArrayGradWithShape` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct TensorArrayGradWithShape {
    source: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'TensorArrayGradWithShape' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct TensorArrayGradWithShapeInst {
    /// An instance of a fully built TensorArrayGradWithShape Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl TensorArrayGradWithShape {
    /// Creates a new `TensorArrayGradWithShape`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `source` attribute.
    pub fn source<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.source = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `TensorArrayGradWithShape` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        handle: O0,
        flow_in: O1,
        shape_to_prepend: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            handle.into(),
            flow_in.into(),
            shape_to_prepend.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        handle: crate::Output,
        flow_in: crate::Output,
        shape_to_prepend: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("TensorArrayGradWithShape", |nd| {
            nd.add_input(handle);
            nd.add_input(flow_in);
            nd.add_input(shape_to_prepend);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.source {
                nd.set_attr_string("source", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'TensorArrayGradWithShape' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        handle: crate::Output,
        flow_in: crate::Output,
        shape_to_prepend: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<TensorArrayGradWithShapeInst> {
        let op = scope.new_operation("TensorArrayGradWithShape", |builder| {
            builder.add_input(handle);
            builder.add_input(flow_in);
            builder.add_input(shape_to_prepend);
            if let ::std::option::Option::Some(value) = &self.source {
                builder.set_attr_string("source", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(TensorArrayGradWithShapeInst { op })
    }
}
impl TensorArrayGradWithShapeInst {
    /// Returns the 'grad_handle' Output of this 'TensorArrayGradWithShape' operation.
    pub fn grad_handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'flow_out' Output of this 'TensorArrayGradWithShape' operation.
    pub fn flow_out(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'handle' Input of this 'TensorArrayGradWithShape' operation.
    pub fn handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'flow_in' Input of this 'TensorArrayGradWithShape' operation.
    pub fn flow_in(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'shape_to_prepend' Input of this 'TensorArrayGradWithShape' operation.
    pub fn shape_to_prepend(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<TensorArrayGradWithShapeInst> for crate::Operation {
    fn from(inst: TensorArrayGradWithShapeInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `TensorArrayGradWithShape::new().build(handle, flow_in, shape_to_prepend, scope)`.
pub fn tensor_array_grad_with_shape<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    handle: O0,
    flow_in: O1,
    shape_to_prepend: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    TensorArrayGradWithShape::new().build(handle, flow_in, shape_to_prepend, scope)
}

/// Builder for the `TensorArrayPack` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct TensorArrayPack {
    dtype: ::std::option::Option<crate::DataType>,
    element_shape: ::std::option::Option<crate::Shape>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'TensorArrayPack' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct TensorArrayPackInst {
    /// An instance of a fully built TensorArrayPack Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl TensorArrayPack {
    /// Creates a new `TensorArrayPack`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `dtype` attribute.
    pub fn dtype<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `element_shape` attribute.
    pub fn element_shape<ArgType: ::std::convert::Into<crate::Shape>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.element_shape = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `TensorArrayPack` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        handle: O0,
        flow_in: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(handle.into(), flow_in.into(), scope)
    }
    fn build_impl(
        &self,
        handle: crate::Output,
        flow_in: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("TensorArrayPack", |nd| {
            nd.add_input(handle);
            nd.add_input(flow_in);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                nd.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.element_shape {
                nd.set_attr_shape("element_shape", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'TensorArrayPack' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        handle: crate::Output,
        flow_in: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<TensorArrayPackInst> {
        let op = scope.new_operation("TensorArrayPack", |builder| {
            builder.add_input(handle);
            builder.add_input(flow_in);
            if let ::std::option::Option::Some(value) = &self.dtype {
                builder.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.element_shape {
                builder.set_attr_shape("element_shape", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(TensorArrayPackInst { op })
    }
}
impl TensorArrayPackInst {
    /// Returns the 'value' Output of this 'TensorArrayPack' operation.
    pub fn value(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'handle' Input of this 'TensorArrayPack' operation.
    pub fn handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'flow_in' Input of this 'TensorArrayPack' operation.
    pub fn flow_in(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<TensorArrayPackInst> for crate::Operation {
    fn from(inst: TensorArrayPackInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `TensorArrayPack::new().build(handle, flow_in, scope)`.
pub fn tensor_array_pack<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    handle: O0,
    flow_in: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    TensorArrayPack::new().build(handle, flow_in, scope)
}

/// Builder for the `TensorArrayRead` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct TensorArrayRead {
    dtype: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'TensorArrayRead' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct TensorArrayReadInst {
    /// An instance of a fully built TensorArrayRead Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl TensorArrayRead {
    /// Creates a new `TensorArrayRead`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `dtype` attribute.
    pub fn dtype<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `TensorArrayRead` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        handle: O0,
        index: O1,
        flow_in: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(handle.into(), index.into(), flow_in.into(), scope)
    }
    fn build_impl(
        &self,
        handle: crate::Output,
        index: crate::Output,
        flow_in: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("TensorArrayRead", |nd| {
            nd.add_input(handle);
            nd.add_input(index);
            nd.add_input(flow_in);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                nd.set_attr_type("dtype", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'TensorArrayRead' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        handle: crate::Output,
        index: crate::Output,
        flow_in: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<TensorArrayReadInst> {
        let op = scope.new_operation("TensorArrayRead", |builder| {
            builder.add_input(handle);
            builder.add_input(index);
            builder.add_input(flow_in);
            if let ::std::option::Option::Some(value) = &self.dtype {
                builder.set_attr_type("dtype", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(TensorArrayReadInst { op })
    }
}
impl TensorArrayReadInst {
    /// Returns the 'value' Output of this 'TensorArrayRead' operation.
    pub fn value(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'handle' Input of this 'TensorArrayRead' operation.
    pub fn handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'index' Input of this 'TensorArrayRead' operation.
    pub fn index(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'flow_in' Input of this 'TensorArrayRead' operation.
    pub fn flow_in(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<TensorArrayReadInst> for crate::Operation {
    fn from(inst: TensorArrayReadInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `TensorArrayRead::new().build(handle, index, flow_in, scope)`.
pub fn tensor_array_read<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    handle: O0,
    index: O1,
    flow_in: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    TensorArrayRead::new().build(handle, index, flow_in, scope)
}

/// Builder for the `TensorArrayReadV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct TensorArrayReadV2 {
    dtype: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'TensorArrayReadV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct TensorArrayReadV2Inst {
    /// An instance of a fully built TensorArrayReadV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl TensorArrayReadV2 {
    /// Creates a new `TensorArrayReadV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `dtype` attribute.
    pub fn dtype<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `TensorArrayReadV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        handle: O0,
        index: O1,
        flow_in: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(handle.into(), index.into(), flow_in.into(), scope)
    }
    fn build_impl(
        &self,
        handle: crate::Output,
        index: crate::Output,
        flow_in: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("TensorArrayReadV2", |nd| {
            nd.add_input(handle);
            nd.add_input(index);
            nd.add_input(flow_in);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                nd.set_attr_type("dtype", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'TensorArrayReadV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        handle: crate::Output,
        index: crate::Output,
        flow_in: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<TensorArrayReadV2Inst> {
        let op = scope.new_operation("TensorArrayReadV2", |builder| {
            builder.add_input(handle);
            builder.add_input(index);
            builder.add_input(flow_in);
            if let ::std::option::Option::Some(value) = &self.dtype {
                builder.set_attr_type("dtype", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(TensorArrayReadV2Inst { op })
    }
}
impl TensorArrayReadV2Inst {
    /// Returns the 'value' Output of this 'TensorArrayReadV2' operation.
    pub fn value(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'handle' Input of this 'TensorArrayReadV2' operation.
    pub fn handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'index' Input of this 'TensorArrayReadV2' operation.
    pub fn index(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'flow_in' Input of this 'TensorArrayReadV2' operation.
    pub fn flow_in(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<TensorArrayReadV2Inst> for crate::Operation {
    fn from(inst: TensorArrayReadV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `TensorArrayReadV2::new().build(handle, index, flow_in, scope)`.
pub fn tensor_array_read_v2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    handle: O0,
    index: O1,
    flow_in: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    TensorArrayReadV2::new().build(handle, index, flow_in, scope)
}

/// Builder for the `TensorArrayReadV3` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct TensorArrayReadV3 {
    dtype: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'TensorArrayReadV3' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct TensorArrayReadV3Inst {
    /// An instance of a fully built TensorArrayReadV3 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl TensorArrayReadV3 {
    /// Creates a new `TensorArrayReadV3`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `dtype` attribute.
    pub fn dtype<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `TensorArrayReadV3` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        handle: O0,
        index: O1,
        flow_in: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(handle.into(), index.into(), flow_in.into(), scope)
    }
    fn build_impl(
        &self,
        handle: crate::Output,
        index: crate::Output,
        flow_in: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("TensorArrayReadV3", |nd| {
            nd.add_input(handle);
            nd.add_input(index);
            nd.add_input(flow_in);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                nd.set_attr_type("dtype", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'TensorArrayReadV3' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        handle: crate::Output,
        index: crate::Output,
        flow_in: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<TensorArrayReadV3Inst> {
        let op = scope.new_operation("TensorArrayReadV3", |builder| {
            builder.add_input(handle);
            builder.add_input(index);
            builder.add_input(flow_in);
            if let ::std::option::Option::Some(value) = &self.dtype {
                builder.set_attr_type("dtype", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(TensorArrayReadV3Inst { op })
    }
}
impl TensorArrayReadV3Inst {
    /// Returns the 'value' Output of this 'TensorArrayReadV3' operation.
    pub fn value(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'handle' Input of this 'TensorArrayReadV3' operation.
    pub fn handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'index' Input of this 'TensorArrayReadV3' operation.
    pub fn index(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'flow_in' Input of this 'TensorArrayReadV3' operation.
    pub fn flow_in(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<TensorArrayReadV3Inst> for crate::Operation {
    fn from(inst: TensorArrayReadV3Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `TensorArrayReadV3::new().build(handle, index, flow_in, scope)`.
pub fn tensor_array_read_v3<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    handle: O0,
    index: O1,
    flow_in: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    TensorArrayReadV3::new().build(handle, index, flow_in, scope)
}

/// Builder for the `TensorArrayScatter` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct TensorArrayScatter {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'TensorArrayScatter' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct TensorArrayScatterInst {
    /// An instance of a fully built TensorArrayScatter Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl TensorArrayScatter {
    /// Creates a new `TensorArrayScatter`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `TensorArrayScatter` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
    >(
        &self,
        handle: O0,
        indices: O1,
        value: O2,
        flow_in: O3,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            handle.into(),
            indices.into(),
            value.into(),
            flow_in.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        handle: crate::Output,
        indices: crate::Output,
        value: crate::Output,
        flow_in: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("TensorArrayScatter", |nd| {
            nd.add_input(handle);
            nd.add_input(indices);
            nd.add_input(value);
            nd.add_input(flow_in);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'TensorArrayScatter' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        handle: crate::Output,
        indices: crate::Output,
        value: crate::Output,
        flow_in: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<TensorArrayScatterInst> {
        let op = scope.new_operation("TensorArrayScatter", |builder| {
            builder.add_input(handle);
            builder.add_input(indices);
            builder.add_input(value);
            builder.add_input(flow_in);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(TensorArrayScatterInst { op })
    }
}
impl TensorArrayScatterInst {
    /// Returns the 'flow_out' Output of this 'TensorArrayScatter' operation.
    pub fn flow_out(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'handle' Input of this 'TensorArrayScatter' operation.
    pub fn handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'indices' Input of this 'TensorArrayScatter' operation.
    pub fn indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'value' Input of this 'TensorArrayScatter' operation.
    pub fn value(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'flow_in' Input of this 'TensorArrayScatter' operation.
    pub fn flow_in(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
}
impl From<TensorArrayScatterInst> for crate::Operation {
    fn from(inst: TensorArrayScatterInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `TensorArrayScatter::new().build(handle, indices, value, flow_in, scope)`.
pub fn tensor_array_scatter<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
>(
    handle: O0,
    indices: O1,
    value: O2,
    flow_in: O3,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    TensorArrayScatter::new().build(handle, indices, value, flow_in, scope)
}

/// Builder for the `TensorArrayScatterV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct TensorArrayScatterV2 {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'TensorArrayScatterV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct TensorArrayScatterV2Inst {
    /// An instance of a fully built TensorArrayScatterV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl TensorArrayScatterV2 {
    /// Creates a new `TensorArrayScatterV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `TensorArrayScatterV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
    >(
        &self,
        handle: O0,
        indices: O1,
        value: O2,
        flow_in: O3,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            handle.into(),
            indices.into(),
            value.into(),
            flow_in.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        handle: crate::Output,
        indices: crate::Output,
        value: crate::Output,
        flow_in: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("TensorArrayScatterV2", |nd| {
            nd.add_input(handle);
            nd.add_input(indices);
            nd.add_input(value);
            nd.add_input(flow_in);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'TensorArrayScatterV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        handle: crate::Output,
        indices: crate::Output,
        value: crate::Output,
        flow_in: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<TensorArrayScatterV2Inst> {
        let op = scope.new_operation("TensorArrayScatterV2", |builder| {
            builder.add_input(handle);
            builder.add_input(indices);
            builder.add_input(value);
            builder.add_input(flow_in);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(TensorArrayScatterV2Inst { op })
    }
}
impl TensorArrayScatterV2Inst {
    /// Returns the 'flow_out' Output of this 'TensorArrayScatterV2' operation.
    pub fn flow_out(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'handle' Input of this 'TensorArrayScatterV2' operation.
    pub fn handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'indices' Input of this 'TensorArrayScatterV2' operation.
    pub fn indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'value' Input of this 'TensorArrayScatterV2' operation.
    pub fn value(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'flow_in' Input of this 'TensorArrayScatterV2' operation.
    pub fn flow_in(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
}
impl From<TensorArrayScatterV2Inst> for crate::Operation {
    fn from(inst: TensorArrayScatterV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `TensorArrayScatterV2::new().build(handle, indices, value, flow_in, scope)`.
pub fn tensor_array_scatter_v2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
>(
    handle: O0,
    indices: O1,
    value: O2,
    flow_in: O3,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    TensorArrayScatterV2::new().build(handle, indices, value, flow_in, scope)
}

/// Builder for the `TensorArrayScatterV3` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct TensorArrayScatterV3 {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'TensorArrayScatterV3' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct TensorArrayScatterV3Inst {
    /// An instance of a fully built TensorArrayScatterV3 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl TensorArrayScatterV3 {
    /// Creates a new `TensorArrayScatterV3`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `TensorArrayScatterV3` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
    >(
        &self,
        handle: O0,
        indices: O1,
        value: O2,
        flow_in: O3,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            handle.into(),
            indices.into(),
            value.into(),
            flow_in.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        handle: crate::Output,
        indices: crate::Output,
        value: crate::Output,
        flow_in: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("TensorArrayScatterV3", |nd| {
            nd.add_input(handle);
            nd.add_input(indices);
            nd.add_input(value);
            nd.add_input(flow_in);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'TensorArrayScatterV3' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        handle: crate::Output,
        indices: crate::Output,
        value: crate::Output,
        flow_in: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<TensorArrayScatterV3Inst> {
        let op = scope.new_operation("TensorArrayScatterV3", |builder| {
            builder.add_input(handle);
            builder.add_input(indices);
            builder.add_input(value);
            builder.add_input(flow_in);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(TensorArrayScatterV3Inst { op })
    }
}
impl TensorArrayScatterV3Inst {
    /// Returns the 'flow_out' Output of this 'TensorArrayScatterV3' operation.
    pub fn flow_out(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'handle' Input of this 'TensorArrayScatterV3' operation.
    pub fn handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'indices' Input of this 'TensorArrayScatterV3' operation.
    pub fn indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'value' Input of this 'TensorArrayScatterV3' operation.
    pub fn value(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'flow_in' Input of this 'TensorArrayScatterV3' operation.
    pub fn flow_in(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
}
impl From<TensorArrayScatterV3Inst> for crate::Operation {
    fn from(inst: TensorArrayScatterV3Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `TensorArrayScatterV3::new().build(handle, indices, value, flow_in, scope)`.
pub fn tensor_array_scatter_v3<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
>(
    handle: O0,
    indices: O1,
    value: O2,
    flow_in: O3,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    TensorArrayScatterV3::new().build(handle, indices, value, flow_in, scope)
}

/// Builder for the `TensorArraySize` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct TensorArraySize {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'TensorArraySize' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct TensorArraySizeInst {
    /// An instance of a fully built TensorArraySize Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl TensorArraySize {
    /// Creates a new `TensorArraySize`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `TensorArraySize` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        handle: O0,
        flow_in: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(handle.into(), flow_in.into(), scope)
    }
    fn build_impl(
        &self,
        handle: crate::Output,
        flow_in: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("TensorArraySize", |nd| {
            nd.add_input(handle);
            nd.add_input(flow_in);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'TensorArraySize' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        handle: crate::Output,
        flow_in: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<TensorArraySizeInst> {
        let op = scope.new_operation("TensorArraySize", |builder| {
            builder.add_input(handle);
            builder.add_input(flow_in);
            ::std::result::Result::Ok(())
        })?;
        Ok(TensorArraySizeInst { op })
    }
}
impl TensorArraySizeInst {
    /// Returns the 'size' Output of this 'TensorArraySize' operation.
    pub fn size(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'handle' Input of this 'TensorArraySize' operation.
    pub fn handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'flow_in' Input of this 'TensorArraySize' operation.
    pub fn flow_in(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<TensorArraySizeInst> for crate::Operation {
    fn from(inst: TensorArraySizeInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `TensorArraySize::new().build(handle, flow_in, scope)`.
pub fn tensor_array_size<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    handle: O0,
    flow_in: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    TensorArraySize::new().build(handle, flow_in, scope)
}

/// Builder for the `TensorArraySizeV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct TensorArraySizeV2 {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'TensorArraySizeV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct TensorArraySizeV2Inst {
    /// An instance of a fully built TensorArraySizeV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl TensorArraySizeV2 {
    /// Creates a new `TensorArraySizeV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `TensorArraySizeV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        handle: O0,
        flow_in: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(handle.into(), flow_in.into(), scope)
    }
    fn build_impl(
        &self,
        handle: crate::Output,
        flow_in: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("TensorArraySizeV2", |nd| {
            nd.add_input(handle);
            nd.add_input(flow_in);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'TensorArraySizeV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        handle: crate::Output,
        flow_in: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<TensorArraySizeV2Inst> {
        let op = scope.new_operation("TensorArraySizeV2", |builder| {
            builder.add_input(handle);
            builder.add_input(flow_in);
            ::std::result::Result::Ok(())
        })?;
        Ok(TensorArraySizeV2Inst { op })
    }
}
impl TensorArraySizeV2Inst {
    /// Returns the 'size' Output of this 'TensorArraySizeV2' operation.
    pub fn size(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'handle' Input of this 'TensorArraySizeV2' operation.
    pub fn handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'flow_in' Input of this 'TensorArraySizeV2' operation.
    pub fn flow_in(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<TensorArraySizeV2Inst> for crate::Operation {
    fn from(inst: TensorArraySizeV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `TensorArraySizeV2::new().build(handle, flow_in, scope)`.
pub fn tensor_array_size_v2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    handle: O0,
    flow_in: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    TensorArraySizeV2::new().build(handle, flow_in, scope)
}

/// Builder for the `TensorArraySizeV3` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct TensorArraySizeV3 {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'TensorArraySizeV3' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct TensorArraySizeV3Inst {
    /// An instance of a fully built TensorArraySizeV3 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl TensorArraySizeV3 {
    /// Creates a new `TensorArraySizeV3`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `TensorArraySizeV3` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        handle: O0,
        flow_in: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(handle.into(), flow_in.into(), scope)
    }
    fn build_impl(
        &self,
        handle: crate::Output,
        flow_in: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("TensorArraySizeV3", |nd| {
            nd.add_input(handle);
            nd.add_input(flow_in);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'TensorArraySizeV3' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        handle: crate::Output,
        flow_in: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<TensorArraySizeV3Inst> {
        let op = scope.new_operation("TensorArraySizeV3", |builder| {
            builder.add_input(handle);
            builder.add_input(flow_in);
            ::std::result::Result::Ok(())
        })?;
        Ok(TensorArraySizeV3Inst { op })
    }
}
impl TensorArraySizeV3Inst {
    /// Returns the 'size' Output of this 'TensorArraySizeV3' operation.
    pub fn size(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'handle' Input of this 'TensorArraySizeV3' operation.
    pub fn handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'flow_in' Input of this 'TensorArraySizeV3' operation.
    pub fn flow_in(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<TensorArraySizeV3Inst> for crate::Operation {
    fn from(inst: TensorArraySizeV3Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `TensorArraySizeV3::new().build(handle, flow_in, scope)`.
pub fn tensor_array_size_v3<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    handle: O0,
    flow_in: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    TensorArraySizeV3::new().build(handle, flow_in, scope)
}

/// Builder for the `TensorArraySplit` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct TensorArraySplit {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'TensorArraySplit' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct TensorArraySplitInst {
    /// An instance of a fully built TensorArraySplit Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl TensorArraySplit {
    /// Creates a new `TensorArraySplit`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `TensorArraySplit` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
    >(
        &self,
        handle: O0,
        value: O1,
        lengths: O2,
        flow_in: O3,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            handle.into(),
            value.into(),
            lengths.into(),
            flow_in.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        handle: crate::Output,
        value: crate::Output,
        lengths: crate::Output,
        flow_in: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("TensorArraySplit", |nd| {
            nd.add_input(handle);
            nd.add_input(value);
            nd.add_input(lengths);
            nd.add_input(flow_in);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'TensorArraySplit' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        handle: crate::Output,
        value: crate::Output,
        lengths: crate::Output,
        flow_in: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<TensorArraySplitInst> {
        let op = scope.new_operation("TensorArraySplit", |builder| {
            builder.add_input(handle);
            builder.add_input(value);
            builder.add_input(lengths);
            builder.add_input(flow_in);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(TensorArraySplitInst { op })
    }
}
impl TensorArraySplitInst {
    /// Returns the 'flow_out' Output of this 'TensorArraySplit' operation.
    pub fn flow_out(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'handle' Input of this 'TensorArraySplit' operation.
    pub fn handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'value' Input of this 'TensorArraySplit' operation.
    pub fn value(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'lengths' Input of this 'TensorArraySplit' operation.
    pub fn lengths(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'flow_in' Input of this 'TensorArraySplit' operation.
    pub fn flow_in(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
}
impl From<TensorArraySplitInst> for crate::Operation {
    fn from(inst: TensorArraySplitInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `TensorArraySplit::new().build(handle, value, lengths, flow_in, scope)`.
pub fn tensor_array_split<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
>(
    handle: O0,
    value: O1,
    lengths: O2,
    flow_in: O3,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    TensorArraySplit::new().build(handle, value, lengths, flow_in, scope)
}

/// Builder for the `TensorArraySplitV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct TensorArraySplitV2 {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'TensorArraySplitV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct TensorArraySplitV2Inst {
    /// An instance of a fully built TensorArraySplitV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl TensorArraySplitV2 {
    /// Creates a new `TensorArraySplitV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `TensorArraySplitV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
    >(
        &self,
        handle: O0,
        value: O1,
        lengths: O2,
        flow_in: O3,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            handle.into(),
            value.into(),
            lengths.into(),
            flow_in.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        handle: crate::Output,
        value: crate::Output,
        lengths: crate::Output,
        flow_in: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("TensorArraySplitV2", |nd| {
            nd.add_input(handle);
            nd.add_input(value);
            nd.add_input(lengths);
            nd.add_input(flow_in);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'TensorArraySplitV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        handle: crate::Output,
        value: crate::Output,
        lengths: crate::Output,
        flow_in: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<TensorArraySplitV2Inst> {
        let op = scope.new_operation("TensorArraySplitV2", |builder| {
            builder.add_input(handle);
            builder.add_input(value);
            builder.add_input(lengths);
            builder.add_input(flow_in);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(TensorArraySplitV2Inst { op })
    }
}
impl TensorArraySplitV2Inst {
    /// Returns the 'flow_out' Output of this 'TensorArraySplitV2' operation.
    pub fn flow_out(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'handle' Input of this 'TensorArraySplitV2' operation.
    pub fn handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'value' Input of this 'TensorArraySplitV2' operation.
    pub fn value(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'lengths' Input of this 'TensorArraySplitV2' operation.
    pub fn lengths(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'flow_in' Input of this 'TensorArraySplitV2' operation.
    pub fn flow_in(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
}
impl From<TensorArraySplitV2Inst> for crate::Operation {
    fn from(inst: TensorArraySplitV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `TensorArraySplitV2::new().build(handle, value, lengths, flow_in, scope)`.
pub fn tensor_array_split_v2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
>(
    handle: O0,
    value: O1,
    lengths: O2,
    flow_in: O3,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    TensorArraySplitV2::new().build(handle, value, lengths, flow_in, scope)
}

/// Builder for the `TensorArraySplitV3` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct TensorArraySplitV3 {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'TensorArraySplitV3' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct TensorArraySplitV3Inst {
    /// An instance of a fully built TensorArraySplitV3 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl TensorArraySplitV3 {
    /// Creates a new `TensorArraySplitV3`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `TensorArraySplitV3` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
    >(
        &self,
        handle: O0,
        value: O1,
        lengths: O2,
        flow_in: O3,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            handle.into(),
            value.into(),
            lengths.into(),
            flow_in.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        handle: crate::Output,
        value: crate::Output,
        lengths: crate::Output,
        flow_in: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("TensorArraySplitV3", |nd| {
            nd.add_input(handle);
            nd.add_input(value);
            nd.add_input(lengths);
            nd.add_input(flow_in);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'TensorArraySplitV3' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        handle: crate::Output,
        value: crate::Output,
        lengths: crate::Output,
        flow_in: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<TensorArraySplitV3Inst> {
        let op = scope.new_operation("TensorArraySplitV3", |builder| {
            builder.add_input(handle);
            builder.add_input(value);
            builder.add_input(lengths);
            builder.add_input(flow_in);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(TensorArraySplitV3Inst { op })
    }
}
impl TensorArraySplitV3Inst {
    /// Returns the 'flow_out' Output of this 'TensorArraySplitV3' operation.
    pub fn flow_out(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'handle' Input of this 'TensorArraySplitV3' operation.
    pub fn handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'value' Input of this 'TensorArraySplitV3' operation.
    pub fn value(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'lengths' Input of this 'TensorArraySplitV3' operation.
    pub fn lengths(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'flow_in' Input of this 'TensorArraySplitV3' operation.
    pub fn flow_in(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
}
impl From<TensorArraySplitV3Inst> for crate::Operation {
    fn from(inst: TensorArraySplitV3Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `TensorArraySplitV3::new().build(handle, value, lengths, flow_in, scope)`.
pub fn tensor_array_split_v3<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
>(
    handle: O0,
    value: O1,
    lengths: O2,
    flow_in: O3,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    TensorArraySplitV3::new().build(handle, value, lengths, flow_in, scope)
}

/// Builder for the `TensorArrayUnpack` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct TensorArrayUnpack {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'TensorArrayUnpack' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct TensorArrayUnpackInst {
    /// An instance of a fully built TensorArrayUnpack Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl TensorArrayUnpack {
    /// Creates a new `TensorArrayUnpack`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `TensorArrayUnpack` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        handle: O0,
        value: O1,
        flow_in: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(handle.into(), value.into(), flow_in.into(), scope)
    }
    fn build_impl(
        &self,
        handle: crate::Output,
        value: crate::Output,
        flow_in: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("TensorArrayUnpack", |nd| {
            nd.add_input(handle);
            nd.add_input(value);
            nd.add_input(flow_in);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'TensorArrayUnpack' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        handle: crate::Output,
        value: crate::Output,
        flow_in: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<TensorArrayUnpackInst> {
        let op = scope.new_operation("TensorArrayUnpack", |builder| {
            builder.add_input(handle);
            builder.add_input(value);
            builder.add_input(flow_in);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(TensorArrayUnpackInst { op })
    }
}
impl TensorArrayUnpackInst {
    /// Returns the 'flow_out' Output of this 'TensorArrayUnpack' operation.
    pub fn flow_out(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'handle' Input of this 'TensorArrayUnpack' operation.
    pub fn handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'value' Input of this 'TensorArrayUnpack' operation.
    pub fn value(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'flow_in' Input of this 'TensorArrayUnpack' operation.
    pub fn flow_in(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<TensorArrayUnpackInst> for crate::Operation {
    fn from(inst: TensorArrayUnpackInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `TensorArrayUnpack::new().build(handle, value, flow_in, scope)`.
pub fn tensor_array_unpack<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    handle: O0,
    value: O1,
    flow_in: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    TensorArrayUnpack::new().build(handle, value, flow_in, scope)
}

/// Builder for the `TensorArrayV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct TensorArrayV2 {
    dtype: ::std::option::Option<crate::DataType>,
    element_shape: ::std::option::Option<crate::Shape>,
    dynamic_size: ::std::option::Option<bool>,
    clear_after_read: ::std::option::Option<bool>,
    tensor_array_name: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'TensorArrayV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct TensorArrayV2Inst {
    /// An instance of a fully built TensorArrayV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl TensorArrayV2 {
    /// Creates a new `TensorArrayV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `dtype` attribute.
    pub fn dtype<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `element_shape` attribute.
    pub fn element_shape<ArgType: ::std::convert::Into<crate::Shape>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.element_shape = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `dynamic_size` attribute.
    pub fn dynamic_size<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.dynamic_size = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `clear_after_read` attribute.
    pub fn clear_after_read<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.clear_after_read = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `tensor_array_name` attribute.
    pub fn tensor_array_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.tensor_array_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `TensorArrayV2` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        size: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(size.into(), scope)
    }
    fn build_impl(
        &self,
        size: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("TensorArrayV2", |nd| {
            nd.add_input(size);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                nd.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.element_shape {
                nd.set_attr_shape("element_shape", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dynamic_size {
                nd.set_attr_bool("dynamic_size", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.clear_after_read {
                nd.set_attr_bool("clear_after_read", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.tensor_array_name {
                nd.set_attr_string("tensor_array_name", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'TensorArrayV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        size: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<TensorArrayV2Inst> {
        let op = scope.new_operation("TensorArrayV2", |builder| {
            builder.add_input(size);
            if let ::std::option::Option::Some(value) = &self.dtype {
                builder.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.element_shape {
                builder.set_attr_shape("element_shape", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dynamic_size {
                builder.set_attr_bool("dynamic_size", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.clear_after_read {
                builder.set_attr_bool("clear_after_read", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.tensor_array_name {
                builder.set_attr_string("tensor_array_name", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(TensorArrayV2Inst { op })
    }
}
impl TensorArrayV2Inst {
    /// Returns the 'handle' Output of this 'TensorArrayV2' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'size' Input of this 'TensorArrayV2' operation.
    pub fn size(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<TensorArrayV2Inst> for crate::Operation {
    fn from(inst: TensorArrayV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `TensorArrayV2::new().build(size, scope)`.
pub fn tensor_array_v2<O0: ::std::convert::Into<crate::Output>>(
    size: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    TensorArrayV2::new().build(size, scope)
}

/// Builder for the `TensorArrayV3` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct TensorArrayV3 {
    dtype: ::std::option::Option<crate::DataType>,
    element_shape: ::std::option::Option<crate::Shape>,
    dynamic_size: ::std::option::Option<bool>,
    clear_after_read: ::std::option::Option<bool>,
    identical_element_shapes: ::std::option::Option<bool>,
    tensor_array_name: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'TensorArrayV3' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct TensorArrayV3Inst {
    /// An instance of a fully built TensorArrayV3 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl TensorArrayV3 {
    /// Creates a new `TensorArrayV3`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `dtype` attribute.
    pub fn dtype<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `element_shape` attribute.
    pub fn element_shape<ArgType: ::std::convert::Into<crate::Shape>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.element_shape = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `dynamic_size` attribute.
    pub fn dynamic_size<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.dynamic_size = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `clear_after_read` attribute.
    pub fn clear_after_read<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.clear_after_read = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `identical_element_shapes` attribute.
    pub fn identical_element_shapes<ArgType: ::std::convert::Into<bool>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.identical_element_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `tensor_array_name` attribute.
    pub fn tensor_array_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.tensor_array_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `TensorArrayV3` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        size: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(size.into(), scope)
    }
    fn build_impl(
        &self,
        size: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("TensorArrayV3", |nd| {
            nd.add_input(size);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                nd.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.element_shape {
                nd.set_attr_shape("element_shape", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dynamic_size {
                nd.set_attr_bool("dynamic_size", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.clear_after_read {
                nd.set_attr_bool("clear_after_read", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.identical_element_shapes {
                nd.set_attr_bool("identical_element_shapes", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.tensor_array_name {
                nd.set_attr_string("tensor_array_name", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'TensorArrayV3' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        size: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<TensorArrayV3Inst> {
        let op = scope.new_operation("TensorArrayV3", |builder| {
            builder.add_input(size);
            if let ::std::option::Option::Some(value) = &self.dtype {
                builder.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.element_shape {
                builder.set_attr_shape("element_shape", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dynamic_size {
                builder.set_attr_bool("dynamic_size", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.clear_after_read {
                builder.set_attr_bool("clear_after_read", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.identical_element_shapes {
                builder.set_attr_bool("identical_element_shapes", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.tensor_array_name {
                builder.set_attr_string("tensor_array_name", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(TensorArrayV3Inst { op })
    }
}
impl TensorArrayV3Inst {
    /// Returns the 'handle' Output of this 'TensorArrayV3' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'flow' Output of this 'TensorArrayV3' operation.
    pub fn flow(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'size' Input of this 'TensorArrayV3' operation.
    pub fn size(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<TensorArrayV3Inst> for crate::Operation {
    fn from(inst: TensorArrayV3Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `TensorArrayV3::new().build(size, scope)`.
pub fn tensor_array_v3<O0: ::std::convert::Into<crate::Output>>(
    size: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    TensorArrayV3::new().build(size, scope)
}

/// Builder for the `TensorArrayWrite` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct TensorArrayWrite {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'TensorArrayWrite' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct TensorArrayWriteInst {
    /// An instance of a fully built TensorArrayWrite Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl TensorArrayWrite {
    /// Creates a new `TensorArrayWrite`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `TensorArrayWrite` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
    >(
        &self,
        handle: O0,
        index: O1,
        value: O2,
        flow_in: O3,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            handle.into(),
            index.into(),
            value.into(),
            flow_in.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        handle: crate::Output,
        index: crate::Output,
        value: crate::Output,
        flow_in: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("TensorArrayWrite", |nd| {
            nd.add_input(handle);
            nd.add_input(index);
            nd.add_input(value);
            nd.add_input(flow_in);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'TensorArrayWrite' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        handle: crate::Output,
        index: crate::Output,
        value: crate::Output,
        flow_in: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<TensorArrayWriteInst> {
        let op = scope.new_operation("TensorArrayWrite", |builder| {
            builder.add_input(handle);
            builder.add_input(index);
            builder.add_input(value);
            builder.add_input(flow_in);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(TensorArrayWriteInst { op })
    }
}
impl TensorArrayWriteInst {
    /// Returns the 'flow_out' Output of this 'TensorArrayWrite' operation.
    pub fn flow_out(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'handle' Input of this 'TensorArrayWrite' operation.
    pub fn handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'index' Input of this 'TensorArrayWrite' operation.
    pub fn index(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'value' Input of this 'TensorArrayWrite' operation.
    pub fn value(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'flow_in' Input of this 'TensorArrayWrite' operation.
    pub fn flow_in(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
}
impl From<TensorArrayWriteInst> for crate::Operation {
    fn from(inst: TensorArrayWriteInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `TensorArrayWrite::new().build(handle, index, value, flow_in, scope)`.
pub fn tensor_array_write<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
>(
    handle: O0,
    index: O1,
    value: O2,
    flow_in: O3,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    TensorArrayWrite::new().build(handle, index, value, flow_in, scope)
}

/// Builder for the `TensorArrayWriteV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct TensorArrayWriteV2 {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'TensorArrayWriteV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct TensorArrayWriteV2Inst {
    /// An instance of a fully built TensorArrayWriteV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl TensorArrayWriteV2 {
    /// Creates a new `TensorArrayWriteV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `TensorArrayWriteV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
    >(
        &self,
        handle: O0,
        index: O1,
        value: O2,
        flow_in: O3,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            handle.into(),
            index.into(),
            value.into(),
            flow_in.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        handle: crate::Output,
        index: crate::Output,
        value: crate::Output,
        flow_in: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("TensorArrayWriteV2", |nd| {
            nd.add_input(handle);
            nd.add_input(index);
            nd.add_input(value);
            nd.add_input(flow_in);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'TensorArrayWriteV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        handle: crate::Output,
        index: crate::Output,
        value: crate::Output,
        flow_in: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<TensorArrayWriteV2Inst> {
        let op = scope.new_operation("TensorArrayWriteV2", |builder| {
            builder.add_input(handle);
            builder.add_input(index);
            builder.add_input(value);
            builder.add_input(flow_in);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(TensorArrayWriteV2Inst { op })
    }
}
impl TensorArrayWriteV2Inst {
    /// Returns the 'flow_out' Output of this 'TensorArrayWriteV2' operation.
    pub fn flow_out(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'handle' Input of this 'TensorArrayWriteV2' operation.
    pub fn handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'index' Input of this 'TensorArrayWriteV2' operation.
    pub fn index(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'value' Input of this 'TensorArrayWriteV2' operation.
    pub fn value(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'flow_in' Input of this 'TensorArrayWriteV2' operation.
    pub fn flow_in(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
}
impl From<TensorArrayWriteV2Inst> for crate::Operation {
    fn from(inst: TensorArrayWriteV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `TensorArrayWriteV2::new().build(handle, index, value, flow_in, scope)`.
pub fn tensor_array_write_v2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
>(
    handle: O0,
    index: O1,
    value: O2,
    flow_in: O3,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    TensorArrayWriteV2::new().build(handle, index, value, flow_in, scope)
}

/// Builder for the `TensorArrayWriteV3` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct TensorArrayWriteV3 {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'TensorArrayWriteV3' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct TensorArrayWriteV3Inst {
    /// An instance of a fully built TensorArrayWriteV3 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl TensorArrayWriteV3 {
    /// Creates a new `TensorArrayWriteV3`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `TensorArrayWriteV3` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
    >(
        &self,
        handle: O0,
        index: O1,
        value: O2,
        flow_in: O3,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            handle.into(),
            index.into(),
            value.into(),
            flow_in.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        handle: crate::Output,
        index: crate::Output,
        value: crate::Output,
        flow_in: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("TensorArrayWriteV3", |nd| {
            nd.add_input(handle);
            nd.add_input(index);
            nd.add_input(value);
            nd.add_input(flow_in);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'TensorArrayWriteV3' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        handle: crate::Output,
        index: crate::Output,
        value: crate::Output,
        flow_in: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<TensorArrayWriteV3Inst> {
        let op = scope.new_operation("TensorArrayWriteV3", |builder| {
            builder.add_input(handle);
            builder.add_input(index);
            builder.add_input(value);
            builder.add_input(flow_in);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(TensorArrayWriteV3Inst { op })
    }
}
impl TensorArrayWriteV3Inst {
    /// Returns the 'flow_out' Output of this 'TensorArrayWriteV3' operation.
    pub fn flow_out(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'handle' Input of this 'TensorArrayWriteV3' operation.
    pub fn handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'index' Input of this 'TensorArrayWriteV3' operation.
    pub fn index(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'value' Input of this 'TensorArrayWriteV3' operation.
    pub fn value(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'flow_in' Input of this 'TensorArrayWriteV3' operation.
    pub fn flow_in(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
}
impl From<TensorArrayWriteV3Inst> for crate::Operation {
    fn from(inst: TensorArrayWriteV3Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `TensorArrayWriteV3::new().build(handle, index, value, flow_in, scope)`.
pub fn tensor_array_write_v3<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
>(
    handle: O0,
    index: O1,
    value: O2,
    flow_in: O3,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    TensorArrayWriteV3::new().build(handle, index, value, flow_in, scope)
}

/// Builder for the `TensorDataset` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct TensorDataset {
    Toutput_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    metadata: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'TensorDataset' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct TensorDatasetInst {
    /// An instance of a fully built TensorDataset Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl TensorDataset {
    /// Creates a new `TensorDataset`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `Toutput_types` attribute.
    pub fn Toutput_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Toutput_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `metadata` attribute.
    pub fn metadata<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.metadata = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `TensorDataset` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        components: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(components.into(), scope)
    }
    fn build_impl(
        &self,
        components: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("TensorDataset", |nd| {
            nd.add_input(components);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.Toutput_types {
                nd.set_attr_type_list("Toutput_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.metadata {
                nd.set_attr_string("metadata", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'TensorDataset' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        components: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<TensorDatasetInst> {
        let op = scope.new_operation("TensorDataset", |builder| {
            builder.add_input(components);
            if let ::std::option::Option::Some(value) = &self.Toutput_types {
                builder.set_attr_type_list("Toutput_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.metadata {
                builder.set_attr_string("metadata", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(TensorDatasetInst { op })
    }
}
impl TensorDatasetInst {
    /// Returns the 'handle' Output of this 'TensorDataset' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'components' Input of this 'TensorDataset' operation.
    pub fn components(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<TensorDatasetInst> for crate::Operation {
    fn from(inst: TensorDatasetInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `TensorDataset::new().build(components, scope)`.
pub fn tensor_dataset<O0: ::std::convert::Into<crate::Output>>(
    components: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    TensorDataset::new().build(components, scope)
}

/// Builder for the `TensorListConcat` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct TensorListConcat {
    element_dtype: ::std::option::Option<crate::DataType>,
    element_shape: ::std::option::Option<crate::Shape>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'TensorListConcat' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct TensorListConcatInst {
    /// An instance of a fully built TensorListConcat Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl TensorListConcat {
    /// Creates a new `TensorListConcat`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `element_dtype` attribute.
    pub fn element_dtype<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.element_dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `element_shape` attribute.
    pub fn element_shape<ArgType: ::std::convert::Into<crate::Shape>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.element_shape = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `TensorListConcat` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input_handle: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input_handle.into(), scope)
    }
    fn build_impl(
        &self,
        input_handle: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("TensorListConcat", |nd| {
            nd.add_input(input_handle);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.element_dtype {
                nd.set_attr_type("element_dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.element_shape {
                nd.set_attr_shape("element_shape", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'TensorListConcat' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_handle: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<TensorListConcatInst> {
        let op = scope.new_operation("TensorListConcat", |builder| {
            builder.add_input(input_handle);
            if let ::std::option::Option::Some(value) = &self.element_dtype {
                builder.set_attr_type("element_dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.element_shape {
                builder.set_attr_shape("element_shape", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(TensorListConcatInst { op })
    }
}
impl TensorListConcatInst {
    /// Returns the 'tensor' Output of this 'TensorListConcat' operation.
    pub fn tensor(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'lengths' Output of this 'TensorListConcat' operation.
    pub fn lengths(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'input_handle' Input of this 'TensorListConcat' operation.
    pub fn input_handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<TensorListConcatInst> for crate::Operation {
    fn from(inst: TensorListConcatInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `TensorListConcat::new().build(input_handle, scope)`.
pub fn tensor_list_concat<O0: ::std::convert::Into<crate::Output>>(
    input_handle: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    TensorListConcat::new().build(input_handle, scope)
}

/// Builder for the `TensorListConcatLists` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct TensorListConcatLists {
    element_dtype: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'TensorListConcatLists' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct TensorListConcatListsInst {
    /// An instance of a fully built TensorListConcatLists Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl TensorListConcatLists {
    /// Creates a new `TensorListConcatLists`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `element_dtype` attribute.
    pub fn element_dtype<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.element_dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `TensorListConcatLists` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input_a: O0,
        input_b: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input_a.into(), input_b.into(), scope)
    }
    fn build_impl(
        &self,
        input_a: crate::Output,
        input_b: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("TensorListConcatLists", |nd| {
            nd.add_input(input_a);
            nd.add_input(input_b);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.element_dtype {
                nd.set_attr_type("element_dtype", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'TensorListConcatLists' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_a: crate::Output,
        input_b: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<TensorListConcatListsInst> {
        let op = scope.new_operation("TensorListConcatLists", |builder| {
            builder.add_input(input_a);
            builder.add_input(input_b);
            if let ::std::option::Option::Some(value) = &self.element_dtype {
                builder.set_attr_type("element_dtype", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(TensorListConcatListsInst { op })
    }
}
impl TensorListConcatListsInst {
    /// Returns the 'output' Output of this 'TensorListConcatLists' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_a' Input of this 'TensorListConcatLists' operation.
    pub fn input_a(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'input_b' Input of this 'TensorListConcatLists' operation.
    pub fn input_b(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<TensorListConcatListsInst> for crate::Operation {
    fn from(inst: TensorListConcatListsInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `TensorListConcatLists::new().build(input_a, input_b, scope)`.
pub fn tensor_list_concat_lists<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    input_a: O0,
    input_b: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    TensorListConcatLists::new().build(input_a, input_b, scope)
}

/// Builder for the `TensorListConcatV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct TensorListConcatV2 {
    element_dtype: ::std::option::Option<crate::DataType>,
    shape_type: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'TensorListConcatV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct TensorListConcatV2Inst {
    /// An instance of a fully built TensorListConcatV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl TensorListConcatV2 {
    /// Creates a new `TensorListConcatV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `element_dtype` attribute.
    pub fn element_dtype<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.element_dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shape_type` attribute.
    pub fn shape_type<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.shape_type = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `TensorListConcatV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input_handle: O0,
        element_shape: O1,
        leading_dims: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            input_handle.into(),
            element_shape.into(),
            leading_dims.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        input_handle: crate::Output,
        element_shape: crate::Output,
        leading_dims: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("TensorListConcatV2", |nd| {
            nd.add_input(input_handle);
            nd.add_input(element_shape);
            nd.add_input(leading_dims);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.element_dtype {
                nd.set_attr_type("element_dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shape_type {
                nd.set_attr_type("shape_type", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'TensorListConcatV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_handle: crate::Output,
        element_shape: crate::Output,
        leading_dims: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<TensorListConcatV2Inst> {
        let op = scope.new_operation("TensorListConcatV2", |builder| {
            builder.add_input(input_handle);
            builder.add_input(element_shape);
            builder.add_input(leading_dims);
            if let ::std::option::Option::Some(value) = &self.element_dtype {
                builder.set_attr_type("element_dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shape_type {
                builder.set_attr_type("shape_type", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(TensorListConcatV2Inst { op })
    }
}
impl TensorListConcatV2Inst {
    /// Returns the 'tensor' Output of this 'TensorListConcatV2' operation.
    pub fn tensor(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'lengths' Output of this 'TensorListConcatV2' operation.
    pub fn lengths(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'input_handle' Input of this 'TensorListConcatV2' operation.
    pub fn input_handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'element_shape' Input of this 'TensorListConcatV2' operation.
    pub fn element_shape(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'leading_dims' Input of this 'TensorListConcatV2' operation.
    pub fn leading_dims(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<TensorListConcatV2Inst> for crate::Operation {
    fn from(inst: TensorListConcatV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `TensorListConcatV2::new().build(input_handle, element_shape, leading_dims, scope)`.
pub fn tensor_list_concat_v2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    input_handle: O0,
    element_shape: O1,
    leading_dims: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    TensorListConcatV2::new().build(input_handle, element_shape, leading_dims, scope)
}

/// Builder for the `TensorListElementShape` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct TensorListElementShape {
    shape_type: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'TensorListElementShape' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct TensorListElementShapeInst {
    /// An instance of a fully built TensorListElementShape Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl TensorListElementShape {
    /// Creates a new `TensorListElementShape`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `shape_type` attribute.
    pub fn shape_type<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.shape_type = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `TensorListElementShape` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input_handle: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input_handle.into(), scope)
    }
    fn build_impl(
        &self,
        input_handle: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("TensorListElementShape", |nd| {
            nd.add_input(input_handle);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.shape_type {
                nd.set_attr_type("shape_type", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'TensorListElementShape' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_handle: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<TensorListElementShapeInst> {
        let op = scope.new_operation("TensorListElementShape", |builder| {
            builder.add_input(input_handle);
            if let ::std::option::Option::Some(value) = &self.shape_type {
                builder.set_attr_type("shape_type", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(TensorListElementShapeInst { op })
    }
}
impl TensorListElementShapeInst {
    /// Returns the 'element_shape' Output of this 'TensorListElementShape' operation.
    pub fn element_shape(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_handle' Input of this 'TensorListElementShape' operation.
    pub fn input_handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<TensorListElementShapeInst> for crate::Operation {
    fn from(inst: TensorListElementShapeInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `TensorListElementShape::new().build(input_handle, scope)`.
pub fn tensor_list_element_shape<O0: ::std::convert::Into<crate::Output>>(
    input_handle: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    TensorListElementShape::new().build(input_handle, scope)
}

/// Builder for the `TensorListFromTensor` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct TensorListFromTensor {
    element_dtype: ::std::option::Option<crate::DataType>,
    shape_type: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'TensorListFromTensor' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct TensorListFromTensorInst {
    /// An instance of a fully built TensorListFromTensor Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl TensorListFromTensor {
    /// Creates a new `TensorListFromTensor`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `element_dtype` attribute.
    pub fn element_dtype<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.element_dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shape_type` attribute.
    pub fn shape_type<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.shape_type = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `TensorListFromTensor` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        tensor: O0,
        element_shape: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(tensor.into(), element_shape.into(), scope)
    }
    fn build_impl(
        &self,
        tensor: crate::Output,
        element_shape: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("TensorListFromTensor", |nd| {
            nd.add_input(tensor);
            nd.add_input(element_shape);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.element_dtype {
                nd.set_attr_type("element_dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shape_type {
                nd.set_attr_type("shape_type", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'TensorListFromTensor' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        tensor: crate::Output,
        element_shape: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<TensorListFromTensorInst> {
        let op = scope.new_operation("TensorListFromTensor", |builder| {
            builder.add_input(tensor);
            builder.add_input(element_shape);
            if let ::std::option::Option::Some(value) = &self.element_dtype {
                builder.set_attr_type("element_dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shape_type {
                builder.set_attr_type("shape_type", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(TensorListFromTensorInst { op })
    }
}
impl TensorListFromTensorInst {
    /// Returns the 'output_handle' Output of this 'TensorListFromTensor' operation.
    pub fn output_handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'tensor' Input of this 'TensorListFromTensor' operation.
    pub fn tensor(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'element_shape' Input of this 'TensorListFromTensor' operation.
    pub fn element_shape(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<TensorListFromTensorInst> for crate::Operation {
    fn from(inst: TensorListFromTensorInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `TensorListFromTensor::new().build(tensor, element_shape, scope)`.
pub fn tensor_list_from_tensor<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    tensor: O0,
    element_shape: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    TensorListFromTensor::new().build(tensor, element_shape, scope)
}

/// Builder for the `TensorListGather` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct TensorListGather {
    element_dtype: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'TensorListGather' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct TensorListGatherInst {
    /// An instance of a fully built TensorListGather Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl TensorListGather {
    /// Creates a new `TensorListGather`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `element_dtype` attribute.
    pub fn element_dtype<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.element_dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `TensorListGather` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input_handle: O0,
        indices: O1,
        element_shape: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            input_handle.into(),
            indices.into(),
            element_shape.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        input_handle: crate::Output,
        indices: crate::Output,
        element_shape: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("TensorListGather", |nd| {
            nd.add_input(input_handle);
            nd.add_input(indices);
            nd.add_input(element_shape);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.element_dtype {
                nd.set_attr_type("element_dtype", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'TensorListGather' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_handle: crate::Output,
        indices: crate::Output,
        element_shape: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<TensorListGatherInst> {
        let op = scope.new_operation("TensorListGather", |builder| {
            builder.add_input(input_handle);
            builder.add_input(indices);
            builder.add_input(element_shape);
            if let ::std::option::Option::Some(value) = &self.element_dtype {
                builder.set_attr_type("element_dtype", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(TensorListGatherInst { op })
    }
}
impl TensorListGatherInst {
    /// Returns the 'values' Output of this 'TensorListGather' operation.
    pub fn values(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_handle' Input of this 'TensorListGather' operation.
    pub fn input_handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'indices' Input of this 'TensorListGather' operation.
    pub fn indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'element_shape' Input of this 'TensorListGather' operation.
    pub fn element_shape(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<TensorListGatherInst> for crate::Operation {
    fn from(inst: TensorListGatherInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `TensorListGather::new().build(input_handle, indices, element_shape, scope)`.
pub fn tensor_list_gather<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    input_handle: O0,
    indices: O1,
    element_shape: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    TensorListGather::new().build(input_handle, indices, element_shape, scope)
}

/// Builder for the `TensorListGetItem` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct TensorListGetItem {
    element_dtype: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'TensorListGetItem' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct TensorListGetItemInst {
    /// An instance of a fully built TensorListGetItem Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl TensorListGetItem {
    /// Creates a new `TensorListGetItem`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `element_dtype` attribute.
    pub fn element_dtype<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.element_dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `TensorListGetItem` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input_handle: O0,
        index: O1,
        element_shape: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            input_handle.into(),
            index.into(),
            element_shape.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        input_handle: crate::Output,
        index: crate::Output,
        element_shape: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("TensorListGetItem", |nd| {
            nd.add_input(input_handle);
            nd.add_input(index);
            nd.add_input(element_shape);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.element_dtype {
                nd.set_attr_type("element_dtype", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'TensorListGetItem' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_handle: crate::Output,
        index: crate::Output,
        element_shape: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<TensorListGetItemInst> {
        let op = scope.new_operation("TensorListGetItem", |builder| {
            builder.add_input(input_handle);
            builder.add_input(index);
            builder.add_input(element_shape);
            if let ::std::option::Option::Some(value) = &self.element_dtype {
                builder.set_attr_type("element_dtype", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(TensorListGetItemInst { op })
    }
}
impl TensorListGetItemInst {
    /// Returns the 'item' Output of this 'TensorListGetItem' operation.
    pub fn item(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_handle' Input of this 'TensorListGetItem' operation.
    pub fn input_handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'index' Input of this 'TensorListGetItem' operation.
    pub fn index(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'element_shape' Input of this 'TensorListGetItem' operation.
    pub fn element_shape(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<TensorListGetItemInst> for crate::Operation {
    fn from(inst: TensorListGetItemInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `TensorListGetItem::new().build(input_handle, index, element_shape, scope)`.
pub fn tensor_list_get_item<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    input_handle: O0,
    index: O1,
    element_shape: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    TensorListGetItem::new().build(input_handle, index, element_shape, scope)
}

/// Builder for the `TensorListLength` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct TensorListLength {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'TensorListLength' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct TensorListLengthInst {
    /// An instance of a fully built TensorListLength Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl TensorListLength {
    /// Creates a new `TensorListLength`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `TensorListLength` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input_handle: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input_handle.into(), scope)
    }
    fn build_impl(
        &self,
        input_handle: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("TensorListLength", |nd| {
            nd.add_input(input_handle);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'TensorListLength' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_handle: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<TensorListLengthInst> {
        let op = scope.new_operation("TensorListLength", |builder| {
            builder.add_input(input_handle);
            ::std::result::Result::Ok(())
        })?;
        Ok(TensorListLengthInst { op })
    }
}
impl TensorListLengthInst {
    /// Returns the 'length' Output of this 'TensorListLength' operation.
    pub fn length(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_handle' Input of this 'TensorListLength' operation.
    pub fn input_handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<TensorListLengthInst> for crate::Operation {
    fn from(inst: TensorListLengthInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `TensorListLength::new().build(input_handle, scope)`.
pub fn tensor_list_length<O0: ::std::convert::Into<crate::Output>>(
    input_handle: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    TensorListLength::new().build(input_handle, scope)
}

/// Builder for the `TensorListPopBack` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct TensorListPopBack {
    element_dtype: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'TensorListPopBack' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct TensorListPopBackInst {
    /// An instance of a fully built TensorListPopBack Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl TensorListPopBack {
    /// Creates a new `TensorListPopBack`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `element_dtype` attribute.
    pub fn element_dtype<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.element_dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `TensorListPopBack` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input_handle: O0,
        element_shape: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input_handle.into(), element_shape.into(), scope)
    }
    fn build_impl(
        &self,
        input_handle: crate::Output,
        element_shape: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("TensorListPopBack", |nd| {
            nd.add_input(input_handle);
            nd.add_input(element_shape);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.element_dtype {
                nd.set_attr_type("element_dtype", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'TensorListPopBack' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_handle: crate::Output,
        element_shape: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<TensorListPopBackInst> {
        let op = scope.new_operation("TensorListPopBack", |builder| {
            builder.add_input(input_handle);
            builder.add_input(element_shape);
            if let ::std::option::Option::Some(value) = &self.element_dtype {
                builder.set_attr_type("element_dtype", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(TensorListPopBackInst { op })
    }
}
impl TensorListPopBackInst {
    /// Returns the 'output_handle' Output of this 'TensorListPopBack' operation.
    pub fn output_handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'tensor' Output of this 'TensorListPopBack' operation.
    pub fn tensor(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'input_handle' Input of this 'TensorListPopBack' operation.
    pub fn input_handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'element_shape' Input of this 'TensorListPopBack' operation.
    pub fn element_shape(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<TensorListPopBackInst> for crate::Operation {
    fn from(inst: TensorListPopBackInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `TensorListPopBack::new().build(input_handle, element_shape, scope)`.
pub fn tensor_list_pop_back<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    input_handle: O0,
    element_shape: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    TensorListPopBack::new().build(input_handle, element_shape, scope)
}

/// Builder for the `TensorListPushBack` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct TensorListPushBack {
    element_dtype: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'TensorListPushBack' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct TensorListPushBackInst {
    /// An instance of a fully built TensorListPushBack Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl TensorListPushBack {
    /// Creates a new `TensorListPushBack`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `element_dtype` attribute.
    pub fn element_dtype<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.element_dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `TensorListPushBack` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input_handle: O0,
        tensor: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input_handle.into(), tensor.into(), scope)
    }
    fn build_impl(
        &self,
        input_handle: crate::Output,
        tensor: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("TensorListPushBack", |nd| {
            nd.add_input(input_handle);
            nd.add_input(tensor);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.element_dtype {
                nd.set_attr_type("element_dtype", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'TensorListPushBack' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_handle: crate::Output,
        tensor: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<TensorListPushBackInst> {
        let op = scope.new_operation("TensorListPushBack", |builder| {
            builder.add_input(input_handle);
            builder.add_input(tensor);
            if let ::std::option::Option::Some(value) = &self.element_dtype {
                builder.set_attr_type("element_dtype", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(TensorListPushBackInst { op })
    }
}
impl TensorListPushBackInst {
    /// Returns the 'output_handle' Output of this 'TensorListPushBack' operation.
    pub fn output_handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_handle' Input of this 'TensorListPushBack' operation.
    pub fn input_handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'tensor' Input of this 'TensorListPushBack' operation.
    pub fn tensor(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<TensorListPushBackInst> for crate::Operation {
    fn from(inst: TensorListPushBackInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `TensorListPushBack::new().build(input_handle, tensor, scope)`.
pub fn tensor_list_push_back<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    input_handle: O0,
    tensor: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    TensorListPushBack::new().build(input_handle, tensor, scope)
}

/// Builder for the `TensorListPushBackBatch` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct TensorListPushBackBatch {
    element_dtype: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'TensorListPushBackBatch' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct TensorListPushBackBatchInst {
    /// An instance of a fully built TensorListPushBackBatch Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl TensorListPushBackBatch {
    /// Creates a new `TensorListPushBackBatch`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `element_dtype` attribute.
    pub fn element_dtype<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.element_dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `TensorListPushBackBatch` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input_handles: O0,
        tensor: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input_handles.into(), tensor.into(), scope)
    }
    fn build_impl(
        &self,
        input_handles: crate::Output,
        tensor: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("TensorListPushBackBatch", |nd| {
            nd.add_input(input_handles);
            nd.add_input(tensor);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.element_dtype {
                nd.set_attr_type("element_dtype", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'TensorListPushBackBatch' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_handles: crate::Output,
        tensor: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<TensorListPushBackBatchInst> {
        let op = scope.new_operation("TensorListPushBackBatch", |builder| {
            builder.add_input(input_handles);
            builder.add_input(tensor);
            if let ::std::option::Option::Some(value) = &self.element_dtype {
                builder.set_attr_type("element_dtype", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(TensorListPushBackBatchInst { op })
    }
}
impl TensorListPushBackBatchInst {
    /// Returns the 'output_handles' Output of this 'TensorListPushBackBatch' operation.
    pub fn output_handles(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_handles' Input of this 'TensorListPushBackBatch' operation.
    pub fn input_handles(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'tensor' Input of this 'TensorListPushBackBatch' operation.
    pub fn tensor(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<TensorListPushBackBatchInst> for crate::Operation {
    fn from(inst: TensorListPushBackBatchInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `TensorListPushBackBatch::new().build(input_handles, tensor, scope)`.
pub fn tensor_list_push_back_batch<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    input_handles: O0,
    tensor: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    TensorListPushBackBatch::new().build(input_handles, tensor, scope)
}

/// Builder for the `TensorListReserve` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct TensorListReserve {
    element_dtype: ::std::option::Option<crate::DataType>,
    shape_type: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'TensorListReserve' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct TensorListReserveInst {
    /// An instance of a fully built TensorListReserve Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl TensorListReserve {
    /// Creates a new `TensorListReserve`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `element_dtype` attribute.
    pub fn element_dtype<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.element_dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shape_type` attribute.
    pub fn shape_type<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.shape_type = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `TensorListReserve` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        element_shape: O0,
        num_elements: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(element_shape.into(), num_elements.into(), scope)
    }
    fn build_impl(
        &self,
        element_shape: crate::Output,
        num_elements: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("TensorListReserve", |nd| {
            nd.add_input(element_shape);
            nd.add_input(num_elements);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.element_dtype {
                nd.set_attr_type("element_dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shape_type {
                nd.set_attr_type("shape_type", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'TensorListReserve' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        element_shape: crate::Output,
        num_elements: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<TensorListReserveInst> {
        let op = scope.new_operation("TensorListReserve", |builder| {
            builder.add_input(element_shape);
            builder.add_input(num_elements);
            if let ::std::option::Option::Some(value) = &self.element_dtype {
                builder.set_attr_type("element_dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shape_type {
                builder.set_attr_type("shape_type", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(TensorListReserveInst { op })
    }
}
impl TensorListReserveInst {
    /// Returns the 'handle' Output of this 'TensorListReserve' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'element_shape' Input of this 'TensorListReserve' operation.
    pub fn element_shape(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'num_elements' Input of this 'TensorListReserve' operation.
    pub fn num_elements(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<TensorListReserveInst> for crate::Operation {
    fn from(inst: TensorListReserveInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `TensorListReserve::new().build(element_shape, num_elements, scope)`.
pub fn tensor_list_reserve<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    element_shape: O0,
    num_elements: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    TensorListReserve::new().build(element_shape, num_elements, scope)
}

/// Builder for the `TensorListResize` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct TensorListResize {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'TensorListResize' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct TensorListResizeInst {
    /// An instance of a fully built TensorListResize Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl TensorListResize {
    /// Creates a new `TensorListResize`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `TensorListResize` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input_handle: O0,
        size: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input_handle.into(), size.into(), scope)
    }
    fn build_impl(
        &self,
        input_handle: crate::Output,
        size: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("TensorListResize", |nd| {
            nd.add_input(input_handle);
            nd.add_input(size);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'TensorListResize' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_handle: crate::Output,
        size: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<TensorListResizeInst> {
        let op = scope.new_operation("TensorListResize", |builder| {
            builder.add_input(input_handle);
            builder.add_input(size);
            ::std::result::Result::Ok(())
        })?;
        Ok(TensorListResizeInst { op })
    }
}
impl TensorListResizeInst {
    /// Returns the 'output_handle' Output of this 'TensorListResize' operation.
    pub fn output_handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_handle' Input of this 'TensorListResize' operation.
    pub fn input_handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'size' Input of this 'TensorListResize' operation.
    pub fn size(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<TensorListResizeInst> for crate::Operation {
    fn from(inst: TensorListResizeInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `TensorListResize::new().build(input_handle, size, scope)`.
pub fn tensor_list_resize<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    input_handle: O0,
    size: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    TensorListResize::new().build(input_handle, size, scope)
}

/// Builder for the `TensorListScatter` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct TensorListScatter {
    element_dtype: ::std::option::Option<crate::DataType>,
    shape_type: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'TensorListScatter' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct TensorListScatterInst {
    /// An instance of a fully built TensorListScatter Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl TensorListScatter {
    /// Creates a new `TensorListScatter`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `element_dtype` attribute.
    pub fn element_dtype<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.element_dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shape_type` attribute.
    pub fn shape_type<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.shape_type = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `TensorListScatter` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        tensor: O0,
        indices: O1,
        element_shape: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(tensor.into(), indices.into(), element_shape.into(), scope)
    }
    fn build_impl(
        &self,
        tensor: crate::Output,
        indices: crate::Output,
        element_shape: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("TensorListScatter", |nd| {
            nd.add_input(tensor);
            nd.add_input(indices);
            nd.add_input(element_shape);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.element_dtype {
                nd.set_attr_type("element_dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shape_type {
                nd.set_attr_type("shape_type", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'TensorListScatter' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        tensor: crate::Output,
        indices: crate::Output,
        element_shape: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<TensorListScatterInst> {
        let op = scope.new_operation("TensorListScatter", |builder| {
            builder.add_input(tensor);
            builder.add_input(indices);
            builder.add_input(element_shape);
            if let ::std::option::Option::Some(value) = &self.element_dtype {
                builder.set_attr_type("element_dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shape_type {
                builder.set_attr_type("shape_type", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(TensorListScatterInst { op })
    }
}
impl TensorListScatterInst {
    /// Returns the 'output_handle' Output of this 'TensorListScatter' operation.
    pub fn output_handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'tensor' Input of this 'TensorListScatter' operation.
    pub fn tensor(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'indices' Input of this 'TensorListScatter' operation.
    pub fn indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'element_shape' Input of this 'TensorListScatter' operation.
    pub fn element_shape(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<TensorListScatterInst> for crate::Operation {
    fn from(inst: TensorListScatterInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `TensorListScatter::new().build(tensor, indices, element_shape, scope)`.
pub fn tensor_list_scatter<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    tensor: O0,
    indices: O1,
    element_shape: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    TensorListScatter::new().build(tensor, indices, element_shape, scope)
}

/// Builder for the `TensorListScatterIntoExistingList` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct TensorListScatterIntoExistingList {
    element_dtype: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'TensorListScatterIntoExistingList' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct TensorListScatterIntoExistingListInst {
    /// An instance of a fully built TensorListScatterIntoExistingList Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl TensorListScatterIntoExistingList {
    /// Creates a new `TensorListScatterIntoExistingList`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `element_dtype` attribute.
    pub fn element_dtype<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.element_dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `TensorListScatterIntoExistingList` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input_handle: O0,
        tensor: O1,
        indices: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input_handle.into(), tensor.into(), indices.into(), scope)
    }
    fn build_impl(
        &self,
        input_handle: crate::Output,
        tensor: crate::Output,
        indices: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("TensorListScatterIntoExistingList", |nd| {
            nd.add_input(input_handle);
            nd.add_input(tensor);
            nd.add_input(indices);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.element_dtype {
                nd.set_attr_type("element_dtype", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'TensorListScatterIntoExistingList' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_handle: crate::Output,
        tensor: crate::Output,
        indices: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<TensorListScatterIntoExistingListInst> {
        let op = scope.new_operation("TensorListScatterIntoExistingList", |builder| {
            builder.add_input(input_handle);
            builder.add_input(tensor);
            builder.add_input(indices);
            if let ::std::option::Option::Some(value) = &self.element_dtype {
                builder.set_attr_type("element_dtype", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(TensorListScatterIntoExistingListInst { op })
    }
}
impl TensorListScatterIntoExistingListInst {
    /// Returns the 'output_handle' Output of this 'TensorListScatterIntoExistingList' operation.
    pub fn output_handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_handle' Input of this 'TensorListScatterIntoExistingList' operation.
    pub fn input_handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'tensor' Input of this 'TensorListScatterIntoExistingList' operation.
    pub fn tensor(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'indices' Input of this 'TensorListScatterIntoExistingList' operation.
    pub fn indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<TensorListScatterIntoExistingListInst> for crate::Operation {
    fn from(inst: TensorListScatterIntoExistingListInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `TensorListScatterIntoExistingList::new().build(input_handle, tensor, indices, scope)`.
pub fn tensor_list_scatter_into_existing_list<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    input_handle: O0,
    tensor: O1,
    indices: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    TensorListScatterIntoExistingList::new().build(input_handle, tensor, indices, scope)
}

/// Builder for the `TensorListScatterV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct TensorListScatterV2 {
    element_dtype: ::std::option::Option<crate::DataType>,
    shape_type: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'TensorListScatterV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct TensorListScatterV2Inst {
    /// An instance of a fully built TensorListScatterV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl TensorListScatterV2 {
    /// Creates a new `TensorListScatterV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `element_dtype` attribute.
    pub fn element_dtype<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.element_dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shape_type` attribute.
    pub fn shape_type<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.shape_type = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `TensorListScatterV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
    >(
        &self,
        tensor: O0,
        indices: O1,
        element_shape: O2,
        num_elements: O3,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            tensor.into(),
            indices.into(),
            element_shape.into(),
            num_elements.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        tensor: crate::Output,
        indices: crate::Output,
        element_shape: crate::Output,
        num_elements: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("TensorListScatterV2", |nd| {
            nd.add_input(tensor);
            nd.add_input(indices);
            nd.add_input(element_shape);
            nd.add_input(num_elements);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.element_dtype {
                nd.set_attr_type("element_dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shape_type {
                nd.set_attr_type("shape_type", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'TensorListScatterV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        tensor: crate::Output,
        indices: crate::Output,
        element_shape: crate::Output,
        num_elements: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<TensorListScatterV2Inst> {
        let op = scope.new_operation("TensorListScatterV2", |builder| {
            builder.add_input(tensor);
            builder.add_input(indices);
            builder.add_input(element_shape);
            builder.add_input(num_elements);
            if let ::std::option::Option::Some(value) = &self.element_dtype {
                builder.set_attr_type("element_dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shape_type {
                builder.set_attr_type("shape_type", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(TensorListScatterV2Inst { op })
    }
}
impl TensorListScatterV2Inst {
    /// Returns the 'output_handle' Output of this 'TensorListScatterV2' operation.
    pub fn output_handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'tensor' Input of this 'TensorListScatterV2' operation.
    pub fn tensor(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'indices' Input of this 'TensorListScatterV2' operation.
    pub fn indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'element_shape' Input of this 'TensorListScatterV2' operation.
    pub fn element_shape(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'num_elements' Input of this 'TensorListScatterV2' operation.
    pub fn num_elements(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
}
impl From<TensorListScatterV2Inst> for crate::Operation {
    fn from(inst: TensorListScatterV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `TensorListScatterV2::new().build(tensor, indices, element_shape, num_elements, scope)`.
pub fn tensor_list_scatter_v2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
>(
    tensor: O0,
    indices: O1,
    element_shape: O2,
    num_elements: O3,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    TensorListScatterV2::new().build(tensor, indices, element_shape, num_elements, scope)
}

/// Builder for the `TensorListSetItem` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct TensorListSetItem {
    element_dtype: ::std::option::Option<crate::DataType>,
    resize_if_index_out_of_bounds: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'TensorListSetItem' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct TensorListSetItemInst {
    /// An instance of a fully built TensorListSetItem Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl TensorListSetItem {
    /// Creates a new `TensorListSetItem`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `element_dtype` attribute.
    pub fn element_dtype<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.element_dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `resize_if_index_out_of_bounds` attribute.
    pub fn resize_if_index_out_of_bounds<ArgType: ::std::convert::Into<bool>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.resize_if_index_out_of_bounds = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `TensorListSetItem` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input_handle: O0,
        index: O1,
        item: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input_handle.into(), index.into(), item.into(), scope)
    }
    fn build_impl(
        &self,
        input_handle: crate::Output,
        index: crate::Output,
        item: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("TensorListSetItem", |nd| {
            nd.add_input(input_handle);
            nd.add_input(index);
            nd.add_input(item);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.element_dtype {
                nd.set_attr_type("element_dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.resize_if_index_out_of_bounds {
                nd.set_attr_bool("resize_if_index_out_of_bounds", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'TensorListSetItem' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_handle: crate::Output,
        index: crate::Output,
        item: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<TensorListSetItemInst> {
        let op = scope.new_operation("TensorListSetItem", |builder| {
            builder.add_input(input_handle);
            builder.add_input(index);
            builder.add_input(item);
            if let ::std::option::Option::Some(value) = &self.element_dtype {
                builder.set_attr_type("element_dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.resize_if_index_out_of_bounds {
                builder.set_attr_bool("resize_if_index_out_of_bounds", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(TensorListSetItemInst { op })
    }
}
impl TensorListSetItemInst {
    /// Returns the 'output_handle' Output of this 'TensorListSetItem' operation.
    pub fn output_handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_handle' Input of this 'TensorListSetItem' operation.
    pub fn input_handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'index' Input of this 'TensorListSetItem' operation.
    pub fn index(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'item' Input of this 'TensorListSetItem' operation.
    pub fn item(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<TensorListSetItemInst> for crate::Operation {
    fn from(inst: TensorListSetItemInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `TensorListSetItem::new().build(input_handle, index, item, scope)`.
pub fn tensor_list_set_item<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    input_handle: O0,
    index: O1,
    item: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    TensorListSetItem::new().build(input_handle, index, item, scope)
}

/// Builder for the `TensorListSplit` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct TensorListSplit {
    element_dtype: ::std::option::Option<crate::DataType>,
    shape_type: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'TensorListSplit' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct TensorListSplitInst {
    /// An instance of a fully built TensorListSplit Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl TensorListSplit {
    /// Creates a new `TensorListSplit`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `element_dtype` attribute.
    pub fn element_dtype<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.element_dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shape_type` attribute.
    pub fn shape_type<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.shape_type = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `TensorListSplit` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        tensor: O0,
        element_shape: O1,
        lengths: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(tensor.into(), element_shape.into(), lengths.into(), scope)
    }
    fn build_impl(
        &self,
        tensor: crate::Output,
        element_shape: crate::Output,
        lengths: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("TensorListSplit", |nd| {
            nd.add_input(tensor);
            nd.add_input(element_shape);
            nd.add_input(lengths);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.element_dtype {
                nd.set_attr_type("element_dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shape_type {
                nd.set_attr_type("shape_type", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'TensorListSplit' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        tensor: crate::Output,
        element_shape: crate::Output,
        lengths: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<TensorListSplitInst> {
        let op = scope.new_operation("TensorListSplit", |builder| {
            builder.add_input(tensor);
            builder.add_input(element_shape);
            builder.add_input(lengths);
            if let ::std::option::Option::Some(value) = &self.element_dtype {
                builder.set_attr_type("element_dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shape_type {
                builder.set_attr_type("shape_type", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(TensorListSplitInst { op })
    }
}
impl TensorListSplitInst {
    /// Returns the 'output_handle' Output of this 'TensorListSplit' operation.
    pub fn output_handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'tensor' Input of this 'TensorListSplit' operation.
    pub fn tensor(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'element_shape' Input of this 'TensorListSplit' operation.
    pub fn element_shape(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'lengths' Input of this 'TensorListSplit' operation.
    pub fn lengths(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<TensorListSplitInst> for crate::Operation {
    fn from(inst: TensorListSplitInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `TensorListSplit::new().build(tensor, element_shape, lengths, scope)`.
pub fn tensor_list_split<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    tensor: O0,
    element_shape: O1,
    lengths: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    TensorListSplit::new().build(tensor, element_shape, lengths, scope)
}

/// Builder for the `TensorListStack` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct TensorListStack {
    element_dtype: ::std::option::Option<crate::DataType>,
    num_elements: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'TensorListStack' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct TensorListStackInst {
    /// An instance of a fully built TensorListStack Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl TensorListStack {
    /// Creates a new `TensorListStack`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `element_dtype` attribute.
    pub fn element_dtype<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.element_dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `num_elements` attribute.
    pub fn num_elements<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.num_elements = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `TensorListStack` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input_handle: O0,
        element_shape: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input_handle.into(), element_shape.into(), scope)
    }
    fn build_impl(
        &self,
        input_handle: crate::Output,
        element_shape: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("TensorListStack", |nd| {
            nd.add_input(input_handle);
            nd.add_input(element_shape);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.element_dtype {
                nd.set_attr_type("element_dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_elements {
                nd.set_attr_int("num_elements", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'TensorListStack' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_handle: crate::Output,
        element_shape: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<TensorListStackInst> {
        let op = scope.new_operation("TensorListStack", |builder| {
            builder.add_input(input_handle);
            builder.add_input(element_shape);
            if let ::std::option::Option::Some(value) = &self.element_dtype {
                builder.set_attr_type("element_dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_elements {
                builder.set_attr_int("num_elements", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(TensorListStackInst { op })
    }
}
impl TensorListStackInst {
    /// Returns the 'tensor' Output of this 'TensorListStack' operation.
    pub fn tensor(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_handle' Input of this 'TensorListStack' operation.
    pub fn input_handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'element_shape' Input of this 'TensorListStack' operation.
    pub fn element_shape(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<TensorListStackInst> for crate::Operation {
    fn from(inst: TensorListStackInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `TensorListStack::new().build(input_handle, element_shape, scope)`.
pub fn tensor_list_stack<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    input_handle: O0,
    element_shape: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    TensorListStack::new().build(input_handle, element_shape, scope)
}

/// Builder for the `TensorMapErase` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct TensorMapErase {
    key_dtype: ::std::option::Option<crate::DataType>,
    value_dtype: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'TensorMapErase' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct TensorMapEraseInst {
    /// An instance of a fully built TensorMapErase Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl TensorMapErase {
    /// Creates a new `TensorMapErase`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `key_dtype` attribute.
    pub fn key_dtype<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.key_dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `value_dtype` attribute.
    pub fn value_dtype<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.value_dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `TensorMapErase` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input_handle: O0,
        key: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input_handle.into(), key.into(), scope)
    }
    fn build_impl(
        &self,
        input_handle: crate::Output,
        key: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("TensorMapErase", |nd| {
            nd.add_input(input_handle);
            nd.add_input(key);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.key_dtype {
                nd.set_attr_type("key_dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.value_dtype {
                nd.set_attr_type("value_dtype", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'TensorMapErase' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_handle: crate::Output,
        key: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<TensorMapEraseInst> {
        let op = scope.new_operation("TensorMapErase", |builder| {
            builder.add_input(input_handle);
            builder.add_input(key);
            if let ::std::option::Option::Some(value) = &self.key_dtype {
                builder.set_attr_type("key_dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.value_dtype {
                builder.set_attr_type("value_dtype", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(TensorMapEraseInst { op })
    }
}
impl TensorMapEraseInst {
    /// Returns the 'output_handle' Output of this 'TensorMapErase' operation.
    pub fn output_handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_handle' Input of this 'TensorMapErase' operation.
    pub fn input_handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'key' Input of this 'TensorMapErase' operation.
    pub fn key(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<TensorMapEraseInst> for crate::Operation {
    fn from(inst: TensorMapEraseInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `TensorMapErase::new().build(input_handle, key, scope)`.
pub fn tensor_map_erase<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    input_handle: O0,
    key: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    TensorMapErase::new().build(input_handle, key, scope)
}

/// Builder for the `TensorMapHasKey` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct TensorMapHasKey {
    key_dtype: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'TensorMapHasKey' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct TensorMapHasKeyInst {
    /// An instance of a fully built TensorMapHasKey Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl TensorMapHasKey {
    /// Creates a new `TensorMapHasKey`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `key_dtype` attribute.
    pub fn key_dtype<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.key_dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `TensorMapHasKey` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input_handle: O0,
        key: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input_handle.into(), key.into(), scope)
    }
    fn build_impl(
        &self,
        input_handle: crate::Output,
        key: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("TensorMapHasKey", |nd| {
            nd.add_input(input_handle);
            nd.add_input(key);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.key_dtype {
                nd.set_attr_type("key_dtype", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'TensorMapHasKey' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_handle: crate::Output,
        key: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<TensorMapHasKeyInst> {
        let op = scope.new_operation("TensorMapHasKey", |builder| {
            builder.add_input(input_handle);
            builder.add_input(key);
            if let ::std::option::Option::Some(value) = &self.key_dtype {
                builder.set_attr_type("key_dtype", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(TensorMapHasKeyInst { op })
    }
}
impl TensorMapHasKeyInst {
    /// Returns the 'has_key' Output of this 'TensorMapHasKey' operation.
    pub fn has_key(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_handle' Input of this 'TensorMapHasKey' operation.
    pub fn input_handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'key' Input of this 'TensorMapHasKey' operation.
    pub fn key(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<TensorMapHasKeyInst> for crate::Operation {
    fn from(inst: TensorMapHasKeyInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `TensorMapHasKey::new().build(input_handle, key, scope)`.
pub fn tensor_map_has_key<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    input_handle: O0,
    key: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    TensorMapHasKey::new().build(input_handle, key, scope)
}

/// Builder for the `TensorMapInsert` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct TensorMapInsert {
    key_dtype: ::std::option::Option<crate::DataType>,
    value_dtype: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'TensorMapInsert' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct TensorMapInsertInst {
    /// An instance of a fully built TensorMapInsert Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl TensorMapInsert {
    /// Creates a new `TensorMapInsert`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `key_dtype` attribute.
    pub fn key_dtype<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.key_dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `value_dtype` attribute.
    pub fn value_dtype<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.value_dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `TensorMapInsert` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input_handle: O0,
        key: O1,
        value: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input_handle.into(), key.into(), value.into(), scope)
    }
    fn build_impl(
        &self,
        input_handle: crate::Output,
        key: crate::Output,
        value: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("TensorMapInsert", |nd| {
            nd.add_input(input_handle);
            nd.add_input(key);
            nd.add_input(value);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.key_dtype {
                nd.set_attr_type("key_dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.value_dtype {
                nd.set_attr_type("value_dtype", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'TensorMapInsert' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_handle: crate::Output,
        key: crate::Output,
        value: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<TensorMapInsertInst> {
        let op = scope.new_operation("TensorMapInsert", |builder| {
            builder.add_input(input_handle);
            builder.add_input(key);
            builder.add_input(value);
            if let ::std::option::Option::Some(value) = &self.key_dtype {
                builder.set_attr_type("key_dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.value_dtype {
                builder.set_attr_type("value_dtype", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(TensorMapInsertInst { op })
    }
}
impl TensorMapInsertInst {
    /// Returns the 'output_handle' Output of this 'TensorMapInsert' operation.
    pub fn output_handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_handle' Input of this 'TensorMapInsert' operation.
    pub fn input_handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'key' Input of this 'TensorMapInsert' operation.
    pub fn key(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'value' Input of this 'TensorMapInsert' operation.
    pub fn value(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<TensorMapInsertInst> for crate::Operation {
    fn from(inst: TensorMapInsertInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `TensorMapInsert::new().build(input_handle, key, value, scope)`.
pub fn tensor_map_insert<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    input_handle: O0,
    key: O1,
    value: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    TensorMapInsert::new().build(input_handle, key, value, scope)
}

/// Builder for the `TensorMapLookup` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct TensorMapLookup {
    key_dtype: ::std::option::Option<crate::DataType>,
    value_dtype: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'TensorMapLookup' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct TensorMapLookupInst {
    /// An instance of a fully built TensorMapLookup Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl TensorMapLookup {
    /// Creates a new `TensorMapLookup`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `key_dtype` attribute.
    pub fn key_dtype<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.key_dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `value_dtype` attribute.
    pub fn value_dtype<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.value_dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `TensorMapLookup` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input_handle: O0,
        key: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input_handle.into(), key.into(), scope)
    }
    fn build_impl(
        &self,
        input_handle: crate::Output,
        key: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("TensorMapLookup", |nd| {
            nd.add_input(input_handle);
            nd.add_input(key);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.key_dtype {
                nd.set_attr_type("key_dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.value_dtype {
                nd.set_attr_type("value_dtype", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'TensorMapLookup' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_handle: crate::Output,
        key: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<TensorMapLookupInst> {
        let op = scope.new_operation("TensorMapLookup", |builder| {
            builder.add_input(input_handle);
            builder.add_input(key);
            if let ::std::option::Option::Some(value) = &self.key_dtype {
                builder.set_attr_type("key_dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.value_dtype {
                builder.set_attr_type("value_dtype", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(TensorMapLookupInst { op })
    }
}
impl TensorMapLookupInst {
    /// Returns the 'value' Output of this 'TensorMapLookup' operation.
    pub fn value(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_handle' Input of this 'TensorMapLookup' operation.
    pub fn input_handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'key' Input of this 'TensorMapLookup' operation.
    pub fn key(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<TensorMapLookupInst> for crate::Operation {
    fn from(inst: TensorMapLookupInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `TensorMapLookup::new().build(input_handle, key, scope)`.
pub fn tensor_map_lookup<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    input_handle: O0,
    key: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    TensorMapLookup::new().build(input_handle, key, scope)
}

/// Builder for the `TensorMapSize` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct TensorMapSize {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'TensorMapSize' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct TensorMapSizeInst {
    /// An instance of a fully built TensorMapSize Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl TensorMapSize {
    /// Creates a new `TensorMapSize`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `TensorMapSize` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input_handle: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input_handle.into(), scope)
    }
    fn build_impl(
        &self,
        input_handle: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("TensorMapSize", |nd| {
            nd.add_input(input_handle);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'TensorMapSize' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_handle: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<TensorMapSizeInst> {
        let op = scope.new_operation("TensorMapSize", |builder| {
            builder.add_input(input_handle);
            ::std::result::Result::Ok(())
        })?;
        Ok(TensorMapSizeInst { op })
    }
}
impl TensorMapSizeInst {
    /// Returns the 'size' Output of this 'TensorMapSize' operation.
    pub fn size(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_handle' Input of this 'TensorMapSize' operation.
    pub fn input_handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<TensorMapSizeInst> for crate::Operation {
    fn from(inst: TensorMapSizeInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `TensorMapSize::new().build(input_handle, scope)`.
pub fn tensor_map_size<O0: ::std::convert::Into<crate::Output>>(
    input_handle: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    TensorMapSize::new().build(input_handle, scope)
}

/// Builder for the `TensorMapStackKeys` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct TensorMapStackKeys {
    key_dtype: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'TensorMapStackKeys' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct TensorMapStackKeysInst {
    /// An instance of a fully built TensorMapStackKeys Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl TensorMapStackKeys {
    /// Creates a new `TensorMapStackKeys`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `key_dtype` attribute.
    pub fn key_dtype<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.key_dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `TensorMapStackKeys` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input_handle: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input_handle.into(), scope)
    }
    fn build_impl(
        &self,
        input_handle: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("TensorMapStackKeys", |nd| {
            nd.add_input(input_handle);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.key_dtype {
                nd.set_attr_type("key_dtype", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'TensorMapStackKeys' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_handle: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<TensorMapStackKeysInst> {
        let op = scope.new_operation("TensorMapStackKeys", |builder| {
            builder.add_input(input_handle);
            if let ::std::option::Option::Some(value) = &self.key_dtype {
                builder.set_attr_type("key_dtype", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(TensorMapStackKeysInst { op })
    }
}
impl TensorMapStackKeysInst {
    /// Returns the 'keys' Output of this 'TensorMapStackKeys' operation.
    pub fn keys(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_handle' Input of this 'TensorMapStackKeys' operation.
    pub fn input_handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<TensorMapStackKeysInst> for crate::Operation {
    fn from(inst: TensorMapStackKeysInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `TensorMapStackKeys::new().build(input_handle, scope)`.
pub fn tensor_map_stack_keys<O0: ::std::convert::Into<crate::Output>>(
    input_handle: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    TensorMapStackKeys::new().build(input_handle, scope)
}

/// Builder for the `TensorScatterAdd` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct TensorScatterAdd {
    T: ::std::option::Option<crate::DataType>,
    Tindices: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'TensorScatterAdd' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct TensorScatterAddInst {
    /// An instance of a fully built TensorScatterAdd Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl TensorScatterAdd {
    /// Creates a new `TensorScatterAdd`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tindices` attribute.
    pub fn Tindices<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tindices = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `TensorScatterAdd` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        tensor: O0,
        indices: O1,
        updates: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(tensor.into(), indices.into(), updates.into(), scope)
    }
    fn build_impl(
        &self,
        tensor: crate::Output,
        indices: crate::Output,
        updates: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("TensorScatterAdd", |nd| {
            nd.add_input(tensor);
            nd.add_input(indices);
            nd.add_input(updates);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                nd.set_attr_type("Tindices", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'TensorScatterAdd' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        tensor: crate::Output,
        indices: crate::Output,
        updates: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<TensorScatterAddInst> {
        let op = scope.new_operation("TensorScatterAdd", |builder| {
            builder.add_input(tensor);
            builder.add_input(indices);
            builder.add_input(updates);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                builder.set_attr_type("Tindices", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(TensorScatterAddInst { op })
    }
}
impl TensorScatterAddInst {
    /// Returns the 'output' Output of this 'TensorScatterAdd' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'tensor' Input of this 'TensorScatterAdd' operation.
    pub fn tensor(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'indices' Input of this 'TensorScatterAdd' operation.
    pub fn indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'updates' Input of this 'TensorScatterAdd' operation.
    pub fn updates(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<TensorScatterAddInst> for crate::Operation {
    fn from(inst: TensorScatterAddInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `TensorScatterAdd::new().build(tensor, indices, updates, scope)`.
pub fn tensor_scatter_add<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    tensor: O0,
    indices: O1,
    updates: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    TensorScatterAdd::new().build(tensor, indices, updates, scope)
}

/// Builder for the `TensorScatterMax` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct TensorScatterMax {
    T: ::std::option::Option<crate::DataType>,
    Tindices: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'TensorScatterMax' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct TensorScatterMaxInst {
    /// An instance of a fully built TensorScatterMax Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl TensorScatterMax {
    /// Creates a new `TensorScatterMax`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tindices` attribute.
    pub fn Tindices<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tindices = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `TensorScatterMax` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        tensor: O0,
        indices: O1,
        updates: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(tensor.into(), indices.into(), updates.into(), scope)
    }
    fn build_impl(
        &self,
        tensor: crate::Output,
        indices: crate::Output,
        updates: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("TensorScatterMax", |nd| {
            nd.add_input(tensor);
            nd.add_input(indices);
            nd.add_input(updates);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                nd.set_attr_type("Tindices", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'TensorScatterMax' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        tensor: crate::Output,
        indices: crate::Output,
        updates: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<TensorScatterMaxInst> {
        let op = scope.new_operation("TensorScatterMax", |builder| {
            builder.add_input(tensor);
            builder.add_input(indices);
            builder.add_input(updates);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                builder.set_attr_type("Tindices", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(TensorScatterMaxInst { op })
    }
}
impl TensorScatterMaxInst {
    /// Returns the 'output' Output of this 'TensorScatterMax' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'tensor' Input of this 'TensorScatterMax' operation.
    pub fn tensor(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'indices' Input of this 'TensorScatterMax' operation.
    pub fn indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'updates' Input of this 'TensorScatterMax' operation.
    pub fn updates(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<TensorScatterMaxInst> for crate::Operation {
    fn from(inst: TensorScatterMaxInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `TensorScatterMax::new().build(tensor, indices, updates, scope)`.
pub fn tensor_scatter_max<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    tensor: O0,
    indices: O1,
    updates: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    TensorScatterMax::new().build(tensor, indices, updates, scope)
}

/// Builder for the `TensorScatterMin` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct TensorScatterMin {
    T: ::std::option::Option<crate::DataType>,
    Tindices: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'TensorScatterMin' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct TensorScatterMinInst {
    /// An instance of a fully built TensorScatterMin Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl TensorScatterMin {
    /// Creates a new `TensorScatterMin`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tindices` attribute.
    pub fn Tindices<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tindices = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `TensorScatterMin` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        tensor: O0,
        indices: O1,
        updates: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(tensor.into(), indices.into(), updates.into(), scope)
    }
    fn build_impl(
        &self,
        tensor: crate::Output,
        indices: crate::Output,
        updates: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("TensorScatterMin", |nd| {
            nd.add_input(tensor);
            nd.add_input(indices);
            nd.add_input(updates);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                nd.set_attr_type("Tindices", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'TensorScatterMin' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        tensor: crate::Output,
        indices: crate::Output,
        updates: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<TensorScatterMinInst> {
        let op = scope.new_operation("TensorScatterMin", |builder| {
            builder.add_input(tensor);
            builder.add_input(indices);
            builder.add_input(updates);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                builder.set_attr_type("Tindices", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(TensorScatterMinInst { op })
    }
}
impl TensorScatterMinInst {
    /// Returns the 'output' Output of this 'TensorScatterMin' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'tensor' Input of this 'TensorScatterMin' operation.
    pub fn tensor(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'indices' Input of this 'TensorScatterMin' operation.
    pub fn indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'updates' Input of this 'TensorScatterMin' operation.
    pub fn updates(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<TensorScatterMinInst> for crate::Operation {
    fn from(inst: TensorScatterMinInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `TensorScatterMin::new().build(tensor, indices, updates, scope)`.
pub fn tensor_scatter_min<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    tensor: O0,
    indices: O1,
    updates: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    TensorScatterMin::new().build(tensor, indices, updates, scope)
}

/// Builder for the `TensorScatterSub` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct TensorScatterSub {
    T: ::std::option::Option<crate::DataType>,
    Tindices: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'TensorScatterSub' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct TensorScatterSubInst {
    /// An instance of a fully built TensorScatterSub Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl TensorScatterSub {
    /// Creates a new `TensorScatterSub`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tindices` attribute.
    pub fn Tindices<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tindices = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `TensorScatterSub` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        tensor: O0,
        indices: O1,
        updates: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(tensor.into(), indices.into(), updates.into(), scope)
    }
    fn build_impl(
        &self,
        tensor: crate::Output,
        indices: crate::Output,
        updates: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("TensorScatterSub", |nd| {
            nd.add_input(tensor);
            nd.add_input(indices);
            nd.add_input(updates);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                nd.set_attr_type("Tindices", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'TensorScatterSub' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        tensor: crate::Output,
        indices: crate::Output,
        updates: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<TensorScatterSubInst> {
        let op = scope.new_operation("TensorScatterSub", |builder| {
            builder.add_input(tensor);
            builder.add_input(indices);
            builder.add_input(updates);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                builder.set_attr_type("Tindices", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(TensorScatterSubInst { op })
    }
}
impl TensorScatterSubInst {
    /// Returns the 'output' Output of this 'TensorScatterSub' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'tensor' Input of this 'TensorScatterSub' operation.
    pub fn tensor(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'indices' Input of this 'TensorScatterSub' operation.
    pub fn indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'updates' Input of this 'TensorScatterSub' operation.
    pub fn updates(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<TensorScatterSubInst> for crate::Operation {
    fn from(inst: TensorScatterSubInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `TensorScatterSub::new().build(tensor, indices, updates, scope)`.
pub fn tensor_scatter_sub<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    tensor: O0,
    indices: O1,
    updates: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    TensorScatterSub::new().build(tensor, indices, updates, scope)
}

/// Builder for the `TensorScatterUpdate` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct TensorScatterUpdate {
    T: ::std::option::Option<crate::DataType>,
    Tindices: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'TensorScatterUpdate' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct TensorScatterUpdateInst {
    /// An instance of a fully built TensorScatterUpdate Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl TensorScatterUpdate {
    /// Creates a new `TensorScatterUpdate`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tindices` attribute.
    pub fn Tindices<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tindices = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `TensorScatterUpdate` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        tensor: O0,
        indices: O1,
        updates: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(tensor.into(), indices.into(), updates.into(), scope)
    }
    fn build_impl(
        &self,
        tensor: crate::Output,
        indices: crate::Output,
        updates: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("TensorScatterUpdate", |nd| {
            nd.add_input(tensor);
            nd.add_input(indices);
            nd.add_input(updates);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                nd.set_attr_type("Tindices", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'TensorScatterUpdate' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        tensor: crate::Output,
        indices: crate::Output,
        updates: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<TensorScatterUpdateInst> {
        let op = scope.new_operation("TensorScatterUpdate", |builder| {
            builder.add_input(tensor);
            builder.add_input(indices);
            builder.add_input(updates);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                builder.set_attr_type("Tindices", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(TensorScatterUpdateInst { op })
    }
}
impl TensorScatterUpdateInst {
    /// Returns the 'output' Output of this 'TensorScatterUpdate' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'tensor' Input of this 'TensorScatterUpdate' operation.
    pub fn tensor(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'indices' Input of this 'TensorScatterUpdate' operation.
    pub fn indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'updates' Input of this 'TensorScatterUpdate' operation.
    pub fn updates(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<TensorScatterUpdateInst> for crate::Operation {
    fn from(inst: TensorScatterUpdateInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `TensorScatterUpdate::new().build(tensor, indices, updates, scope)`.
pub fn tensor_scatter_update<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    tensor: O0,
    indices: O1,
    updates: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    TensorScatterUpdate::new().build(tensor, indices, updates, scope)
}

/// Builder for the `TensorSliceDataset` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct TensorSliceDataset {
    Toutput_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    is_files: ::std::option::Option<bool>,
    metadata: ::std::option::Option<::std::string::String>,
    replicate_on_split: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'TensorSliceDataset' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct TensorSliceDatasetInst {
    /// An instance of a fully built TensorSliceDataset Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl TensorSliceDataset {
    /// Creates a new `TensorSliceDataset`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `Toutput_types` attribute.
    pub fn Toutput_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Toutput_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `is_files` attribute.
    pub fn is_files<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.is_files = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `metadata` attribute.
    pub fn metadata<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.metadata = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `replicate_on_split` attribute.
    pub fn replicate_on_split<ArgType: ::std::convert::Into<bool>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.replicate_on_split = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `TensorSliceDataset` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        components: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(components.into(), scope)
    }
    fn build_impl(
        &self,
        components: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("TensorSliceDataset", |nd| {
            nd.add_input(components);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.Toutput_types {
                nd.set_attr_type_list("Toutput_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.is_files {
                nd.set_attr_bool("is_files", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.metadata {
                nd.set_attr_string("metadata", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.replicate_on_split {
                nd.set_attr_bool("replicate_on_split", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'TensorSliceDataset' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        components: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<TensorSliceDatasetInst> {
        let op = scope.new_operation("TensorSliceDataset", |builder| {
            builder.add_input(components);
            if let ::std::option::Option::Some(value) = &self.Toutput_types {
                builder.set_attr_type_list("Toutput_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.is_files {
                builder.set_attr_bool("is_files", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.metadata {
                builder.set_attr_string("metadata", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.replicate_on_split {
                builder.set_attr_bool("replicate_on_split", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(TensorSliceDatasetInst { op })
    }
}
impl TensorSliceDatasetInst {
    /// Returns the 'handle' Output of this 'TensorSliceDataset' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'components' Input of this 'TensorSliceDataset' operation.
    pub fn components(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<TensorSliceDatasetInst> for crate::Operation {
    fn from(inst: TensorSliceDatasetInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `TensorSliceDataset::new().build(components, scope)`.
pub fn tensor_slice_dataset<O0: ::std::convert::Into<crate::Output>>(
    components: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    TensorSliceDataset::new().build(components, scope)
}

/// Builder for the `TensorStridedSliceUpdate` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct TensorStridedSliceUpdate {
    T: ::std::option::Option<crate::DataType>,
    Index: ::std::option::Option<crate::DataType>,
    begin_mask: ::std::option::Option<i64>,
    end_mask: ::std::option::Option<i64>,
    ellipsis_mask: ::std::option::Option<i64>,
    new_axis_mask: ::std::option::Option<i64>,
    shrink_axis_mask: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'TensorStridedSliceUpdate' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct TensorStridedSliceUpdateInst {
    /// An instance of a fully built TensorStridedSliceUpdate Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl TensorStridedSliceUpdate {
    /// Creates a new `TensorStridedSliceUpdate`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Index` attribute.
    pub fn Index<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Index = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `begin_mask` attribute.
    pub fn begin_mask<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.begin_mask = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `end_mask` attribute.
    pub fn end_mask<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.end_mask = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `ellipsis_mask` attribute.
    pub fn ellipsis_mask<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.ellipsis_mask = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `new_axis_mask` attribute.
    pub fn new_axis_mask<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.new_axis_mask = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shrink_axis_mask` attribute.
    pub fn shrink_axis_mask<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.shrink_axis_mask = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `TensorStridedSliceUpdate` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        begin: O1,
        end: O2,
        strides: O3,
        value: O4,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            input.into(),
            begin.into(),
            end.into(),
            strides.into(),
            value.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        input: crate::Output,
        begin: crate::Output,
        end: crate::Output,
        strides: crate::Output,
        value: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("TensorStridedSliceUpdate", |nd| {
            nd.add_input(input);
            nd.add_input(begin);
            nd.add_input(end);
            nd.add_input(strides);
            nd.add_input(value);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Index {
                nd.set_attr_type("Index", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.begin_mask {
                nd.set_attr_int("begin_mask", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.end_mask {
                nd.set_attr_int("end_mask", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.ellipsis_mask {
                nd.set_attr_int("ellipsis_mask", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.new_axis_mask {
                nd.set_attr_int("new_axis_mask", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shrink_axis_mask {
                nd.set_attr_int("shrink_axis_mask", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'TensorStridedSliceUpdate' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        begin: crate::Output,
        end: crate::Output,
        strides: crate::Output,
        value: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<TensorStridedSliceUpdateInst> {
        let op = scope.new_operation("TensorStridedSliceUpdate", |builder| {
            builder.add_input(input);
            builder.add_input(begin);
            builder.add_input(end);
            builder.add_input(strides);
            builder.add_input(value);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Index {
                builder.set_attr_type("Index", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.begin_mask {
                builder.set_attr_int("begin_mask", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.end_mask {
                builder.set_attr_int("end_mask", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.ellipsis_mask {
                builder.set_attr_int("ellipsis_mask", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.new_axis_mask {
                builder.set_attr_int("new_axis_mask", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shrink_axis_mask {
                builder.set_attr_int("shrink_axis_mask", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(TensorStridedSliceUpdateInst { op })
    }
}
impl TensorStridedSliceUpdateInst {
    /// Returns the 'output' Output of this 'TensorStridedSliceUpdate' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'TensorStridedSliceUpdate' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'begin' Input of this 'TensorStridedSliceUpdate' operation.
    pub fn begin(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'end' Input of this 'TensorStridedSliceUpdate' operation.
    pub fn end(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'strides' Input of this 'TensorStridedSliceUpdate' operation.
    pub fn strides(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'value' Input of this 'TensorStridedSliceUpdate' operation.
    pub fn value(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
}
impl From<TensorStridedSliceUpdateInst> for crate::Operation {
    fn from(inst: TensorStridedSliceUpdateInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `TensorStridedSliceUpdate::new().build(input, begin, end, strides, value, scope)`.
pub fn tensor_strided_slice_update<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
>(
    input: O0,
    begin: O1,
    end: O2,
    strides: O3,
    value: O4,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    TensorStridedSliceUpdate::new().build(input, begin, end, strides, value, scope)
}

/// Builder for the `TensorSummary` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct TensorSummary {
    T: ::std::option::Option<crate::DataType>,
    description: ::std::option::Option<::std::string::String>,
    labels: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
    display_name: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'TensorSummary' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct TensorSummaryInst {
    /// An instance of a fully built TensorSummary Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl TensorSummary {
    /// Creates a new `TensorSummary`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `description` attribute.
    pub fn description<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.description = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `labels` attribute.
    pub fn labels<ArgType: ::std::convert::Into<::std::vec::Vec<::std::string::String>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.labels = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `display_name` attribute.
    pub fn display_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.display_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `TensorSummary` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        tensor: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(tensor.into(), scope)
    }
    fn build_impl(
        &self,
        tensor: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("TensorSummary", |nd| {
            nd.add_input(tensor);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.description {
                nd.set_attr_string("description", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.labels {
                nd.set_attr_string_list("labels", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.display_name {
                nd.set_attr_string("display_name", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'TensorSummary' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        tensor: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<TensorSummaryInst> {
        let op = scope.new_operation("TensorSummary", |builder| {
            builder.add_input(tensor);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.description {
                builder.set_attr_string("description", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.labels {
                builder.set_attr_string_list("labels", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.display_name {
                builder.set_attr_string("display_name", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(TensorSummaryInst { op })
    }
}
impl TensorSummaryInst {
    /// Returns the 'summary' Output of this 'TensorSummary' operation.
    pub fn summary(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'tensor' Input of this 'TensorSummary' operation.
    pub fn tensor(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<TensorSummaryInst> for crate::Operation {
    fn from(inst: TensorSummaryInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `TensorSummary::new().build(tensor, scope)`.
pub fn tensor_summary<O0: ::std::convert::Into<crate::Output>>(
    tensor: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    TensorSummary::new().build(tensor, scope)
}

/// Builder for the `TensorSummaryV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct TensorSummaryV2 {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'TensorSummaryV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct TensorSummaryV2Inst {
    /// An instance of a fully built TensorSummaryV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl TensorSummaryV2 {
    /// Creates a new `TensorSummaryV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `TensorSummaryV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        tag: O0,
        tensor: O1,
        serialized_summary_metadata: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            tag.into(),
            tensor.into(),
            serialized_summary_metadata.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        tag: crate::Output,
        tensor: crate::Output,
        serialized_summary_metadata: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("TensorSummaryV2", |nd| {
            nd.add_input(tag);
            nd.add_input(tensor);
            nd.add_input(serialized_summary_metadata);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'TensorSummaryV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        tag: crate::Output,
        tensor: crate::Output,
        serialized_summary_metadata: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<TensorSummaryV2Inst> {
        let op = scope.new_operation("TensorSummaryV2", |builder| {
            builder.add_input(tag);
            builder.add_input(tensor);
            builder.add_input(serialized_summary_metadata);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(TensorSummaryV2Inst { op })
    }
}
impl TensorSummaryV2Inst {
    /// Returns the 'summary' Output of this 'TensorSummaryV2' operation.
    pub fn summary(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'tag' Input of this 'TensorSummaryV2' operation.
    pub fn tag(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'tensor' Input of this 'TensorSummaryV2' operation.
    pub fn tensor(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'serialized_summary_metadata' Input of this 'TensorSummaryV2' operation.
    pub fn serialized_summary_metadata(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<TensorSummaryV2Inst> for crate::Operation {
    fn from(inst: TensorSummaryV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `TensorSummaryV2::new().build(tag, tensor, serialized_summary_metadata, scope)`.
pub fn tensor_summary_v2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    tag: O0,
    tensor: O1,
    serialized_summary_metadata: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    TensorSummaryV2::new().build(tag, tensor, serialized_summary_metadata, scope)
}

/// Builder for the `TextLineDataset` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct TextLineDataset {
    metadata: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'TextLineDataset' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct TextLineDatasetInst {
    /// An instance of a fully built TextLineDataset Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl TextLineDataset {
    /// Creates a new `TextLineDataset`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `metadata` attribute.
    pub fn metadata<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.metadata = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `TextLineDataset` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        filenames: O0,
        compression_type: O1,
        buffer_size: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            filenames.into(),
            compression_type.into(),
            buffer_size.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        filenames: crate::Output,
        compression_type: crate::Output,
        buffer_size: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("TextLineDataset", |nd| {
            nd.add_input(filenames);
            nd.add_input(compression_type);
            nd.add_input(buffer_size);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.metadata {
                nd.set_attr_string("metadata", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'TextLineDataset' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        filenames: crate::Output,
        compression_type: crate::Output,
        buffer_size: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<TextLineDatasetInst> {
        let op = scope.new_operation("TextLineDataset", |builder| {
            builder.add_input(filenames);
            builder.add_input(compression_type);
            builder.add_input(buffer_size);
            if let ::std::option::Option::Some(value) = &self.metadata {
                builder.set_attr_string("metadata", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(TextLineDatasetInst { op })
    }
}
impl TextLineDatasetInst {
    /// Returns the 'handle' Output of this 'TextLineDataset' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'filenames' Input of this 'TextLineDataset' operation.
    pub fn filenames(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'compression_type' Input of this 'TextLineDataset' operation.
    pub fn compression_type(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'buffer_size' Input of this 'TextLineDataset' operation.
    pub fn buffer_size(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<TextLineDatasetInst> for crate::Operation {
    fn from(inst: TextLineDatasetInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `TextLineDataset::new().build(filenames, compression_type, buffer_size, scope)`.
pub fn text_line_dataset<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    filenames: O0,
    compression_type: O1,
    buffer_size: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    TextLineDataset::new().build(filenames, compression_type, buffer_size, scope)
}

/// Builder for the `TextLineReader` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct TextLineReader {
    skip_header_lines: ::std::option::Option<i64>,
    container: ::std::option::Option<::std::string::String>,
    shared_name: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'TextLineReader' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct TextLineReaderInst {
    /// An instance of a fully built TextLineReader Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl TextLineReader {
    /// Creates a new `TextLineReader`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `skip_header_lines` attribute.
    pub fn skip_header_lines<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.skip_header_lines = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `container` attribute.
    pub fn container<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.container = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shared_name` attribute.
    pub fn shared_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.shared_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `TextLineReader` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("TextLineReader", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.skip_header_lines {
                nd.set_attr_int("skip_header_lines", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.container {
                nd.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                nd.set_attr_string("shared_name", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'TextLineReader' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(&self, scope: &mut crate::Scope) -> crate::Result<TextLineReaderInst> {
        let op = scope.new_operation("TextLineReader", |builder| {
            if let ::std::option::Option::Some(value) = &self.skip_header_lines {
                builder.set_attr_int("skip_header_lines", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.container {
                builder.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                builder.set_attr_string("shared_name", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(TextLineReaderInst { op })
    }
}
impl TextLineReaderInst {
    /// Returns the 'reader_handle' Output of this 'TextLineReader' operation.
    pub fn reader_handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
}
impl From<TextLineReaderInst> for crate::Operation {
    fn from(inst: TextLineReaderInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `TextLineReader::new().build(scope)`.
pub fn text_line_reader(scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
    TextLineReader::new().build(scope)
}

/// Builder for the `TextLineReaderV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct TextLineReaderV2 {
    skip_header_lines: ::std::option::Option<i64>,
    container: ::std::option::Option<::std::string::String>,
    shared_name: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'TextLineReaderV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct TextLineReaderV2Inst {
    /// An instance of a fully built TextLineReaderV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl TextLineReaderV2 {
    /// Creates a new `TextLineReaderV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `skip_header_lines` attribute.
    pub fn skip_header_lines<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.skip_header_lines = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `container` attribute.
    pub fn container<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.container = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shared_name` attribute.
    pub fn shared_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.shared_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `TextLineReaderV2` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("TextLineReaderV2", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.skip_header_lines {
                nd.set_attr_int("skip_header_lines", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.container {
                nd.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                nd.set_attr_string("shared_name", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'TextLineReaderV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(&self, scope: &mut crate::Scope) -> crate::Result<TextLineReaderV2Inst> {
        let op = scope.new_operation("TextLineReaderV2", |builder| {
            if let ::std::option::Option::Some(value) = &self.skip_header_lines {
                builder.set_attr_int("skip_header_lines", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.container {
                builder.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                builder.set_attr_string("shared_name", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(TextLineReaderV2Inst { op })
    }
}
impl TextLineReaderV2Inst {
    /// Returns the 'reader_handle' Output of this 'TextLineReaderV2' operation.
    pub fn reader_handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
}
impl From<TextLineReaderV2Inst> for crate::Operation {
    fn from(inst: TextLineReaderV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `TextLineReaderV2::new().build(scope)`.
pub fn text_line_reader_v2(scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
    TextLineReaderV2::new().build(scope)
}

/// Builder for the `ThreadPoolDataset` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ThreadPoolDataset {
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ThreadPoolDataset' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ThreadPoolDatasetInst {
    /// An instance of a fully built ThreadPoolDataset Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ThreadPoolDataset {
    /// Creates a new `ThreadPoolDataset`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ThreadPoolDataset` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input_dataset: O0,
        thread_pool: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input_dataset.into(), thread_pool.into(), scope)
    }
    fn build_impl(
        &self,
        input_dataset: crate::Output,
        thread_pool: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ThreadPoolDataset", |nd| {
            nd.add_input(input_dataset);
            nd.add_input(thread_pool);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ThreadPoolDataset' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_dataset: crate::Output,
        thread_pool: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ThreadPoolDatasetInst> {
        let op = scope.new_operation("ThreadPoolDataset", |builder| {
            builder.add_input(input_dataset);
            builder.add_input(thread_pool);
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ThreadPoolDatasetInst { op })
    }
}
impl ThreadPoolDatasetInst {
    /// Returns the 'handle' Output of this 'ThreadPoolDataset' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_dataset' Input of this 'ThreadPoolDataset' operation.
    pub fn input_dataset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'thread_pool' Input of this 'ThreadPoolDataset' operation.
    pub fn thread_pool(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<ThreadPoolDatasetInst> for crate::Operation {
    fn from(inst: ThreadPoolDatasetInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ThreadPoolDataset::new().build(input_dataset, thread_pool, scope)`.
pub fn thread_pool_dataset<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    input_dataset: O0,
    thread_pool: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ThreadPoolDataset::new().build(input_dataset, thread_pool, scope)
}

/// Builder for the `ThreadPoolHandle` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ThreadPoolHandle {
    num_threads: ::std::option::Option<i64>,
    max_intra_op_parallelism: ::std::option::Option<i64>,
    display_name: ::std::option::Option<::std::string::String>,
    container: ::std::option::Option<::std::string::String>,
    shared_name: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ThreadPoolHandle' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ThreadPoolHandleInst {
    /// An instance of a fully built ThreadPoolHandle Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ThreadPoolHandle {
    /// Creates a new `ThreadPoolHandle`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `num_threads` attribute.
    pub fn num_threads<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.num_threads = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `max_intra_op_parallelism` attribute.
    pub fn max_intra_op_parallelism<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.max_intra_op_parallelism = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `display_name` attribute.
    pub fn display_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.display_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `container` attribute.
    pub fn container<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.container = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shared_name` attribute.
    pub fn shared_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.shared_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ThreadPoolHandle` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("ThreadPoolHandle", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.num_threads {
                nd.set_attr_int("num_threads", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.max_intra_op_parallelism {
                nd.set_attr_int("max_intra_op_parallelism", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.display_name {
                nd.set_attr_string("display_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.container {
                nd.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                nd.set_attr_string("shared_name", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ThreadPoolHandle' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(&self, scope: &mut crate::Scope) -> crate::Result<ThreadPoolHandleInst> {
        let op = scope.new_operation("ThreadPoolHandle", |builder| {
            if let ::std::option::Option::Some(value) = &self.num_threads {
                builder.set_attr_int("num_threads", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.max_intra_op_parallelism {
                builder.set_attr_int("max_intra_op_parallelism", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.display_name {
                builder.set_attr_string("display_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.container {
                builder.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                builder.set_attr_string("shared_name", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ThreadPoolHandleInst { op })
    }
}
impl ThreadPoolHandleInst {
    /// Returns the 'handle' Output of this 'ThreadPoolHandle' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
}
impl From<ThreadPoolHandleInst> for crate::Operation {
    fn from(inst: ThreadPoolHandleInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ThreadPoolHandle::new().build(scope)`.
pub fn thread_pool_handle(scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
    ThreadPoolHandle::new().build(scope)
}

/// Builder for the `ThreadUnsafeUnigramCandidateSampler` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ThreadUnsafeUnigramCandidateSampler {
    num_true: ::std::option::Option<i64>,
    num_sampled: ::std::option::Option<i64>,
    unique: ::std::option::Option<bool>,
    range_max: ::std::option::Option<i64>,
    seed: ::std::option::Option<i64>,
    seed2: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ThreadUnsafeUnigramCandidateSampler' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ThreadUnsafeUnigramCandidateSamplerInst {
    /// An instance of a fully built ThreadUnsafeUnigramCandidateSampler Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ThreadUnsafeUnigramCandidateSampler {
    /// Creates a new `ThreadUnsafeUnigramCandidateSampler`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `num_true` attribute.
    pub fn num_true<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.num_true = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `num_sampled` attribute.
    pub fn num_sampled<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.num_sampled = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `unique` attribute.
    pub fn unique<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.unique = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `range_max` attribute.
    pub fn range_max<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.range_max = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `seed` attribute.
    pub fn seed<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.seed = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `seed2` attribute.
    pub fn seed2<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.seed2 = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ThreadUnsafeUnigramCandidateSampler` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        true_classes: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(true_classes.into(), scope)
    }
    fn build_impl(
        &self,
        true_classes: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ThreadUnsafeUnigramCandidateSampler", |nd| {
            nd.add_input(true_classes);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.num_true {
                nd.set_attr_int("num_true", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_sampled {
                nd.set_attr_int("num_sampled", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.unique {
                nd.set_attr_bool("unique", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.range_max {
                nd.set_attr_int("range_max", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed {
                nd.set_attr_int("seed", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed2 {
                nd.set_attr_int("seed2", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ThreadUnsafeUnigramCandidateSampler' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        true_classes: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ThreadUnsafeUnigramCandidateSamplerInst> {
        let op = scope.new_operation("ThreadUnsafeUnigramCandidateSampler", |builder| {
            builder.add_input(true_classes);
            if let ::std::option::Option::Some(value) = &self.num_true {
                builder.set_attr_int("num_true", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_sampled {
                builder.set_attr_int("num_sampled", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.unique {
                builder.set_attr_bool("unique", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.range_max {
                builder.set_attr_int("range_max", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed {
                builder.set_attr_int("seed", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed2 {
                builder.set_attr_int("seed2", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ThreadUnsafeUnigramCandidateSamplerInst { op })
    }
}
impl ThreadUnsafeUnigramCandidateSamplerInst {
    /// Returns the 'sampled_candidates' Output of this 'ThreadUnsafeUnigramCandidateSampler' operation.
    pub fn sampled_candidates(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'true_expected_count' Output of this 'ThreadUnsafeUnigramCandidateSampler' operation.
    pub fn true_expected_count(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'sampled_expected_count' Output of this 'ThreadUnsafeUnigramCandidateSampler' operation.
    pub fn sampled_expected_count(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns the 'true_classes' Input of this 'ThreadUnsafeUnigramCandidateSampler' operation.
    pub fn true_classes(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<ThreadUnsafeUnigramCandidateSamplerInst> for crate::Operation {
    fn from(inst: ThreadUnsafeUnigramCandidateSamplerInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ThreadUnsafeUnigramCandidateSampler::new().build(true_classes, scope)`.
pub fn thread_unsafe_unigram_candidate_sampler<O0: ::std::convert::Into<crate::Output>>(
    true_classes: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ThreadUnsafeUnigramCandidateSampler::new().build(true_classes, scope)
}

/// Builder for the `Tile` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Tile {
    T: ::std::option::Option<crate::DataType>,
    Tmultiples: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Tile' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct TileInst {
    /// An instance of a fully built Tile Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Tile {
    /// Creates a new `Tile`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tmultiples` attribute.
    pub fn Tmultiples<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tmultiples = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Tile` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        multiples: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), multiples.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        multiples: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Tile", |nd| {
            nd.add_input(input);
            nd.add_input(multiples);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tmultiples {
                nd.set_attr_type("Tmultiples", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Tile' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        multiples: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<TileInst> {
        let op = scope.new_operation("Tile", |builder| {
            builder.add_input(input);
            builder.add_input(multiples);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tmultiples {
                builder.set_attr_type("Tmultiples", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(TileInst { op })
    }
}
impl TileInst {
    /// Returns the 'output' Output of this 'Tile' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'Tile' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'multiples' Input of this 'Tile' operation.
    pub fn multiples(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<TileInst> for crate::Operation {
    fn from(inst: TileInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Tile::new().build(input, multiples, scope)`.
pub fn tile<O0: ::std::convert::Into<crate::Output>, O1: ::std::convert::Into<crate::Output>>(
    input: O0,
    multiples: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Tile::new().build(input, multiples, scope)
}

/// Builder for the `TileGrad` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct TileGrad {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'TileGrad' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct TileGradInst {
    /// An instance of a fully built TileGrad Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl TileGrad {
    /// Creates a new `TileGrad`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `TileGrad` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        multiples: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), multiples.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        multiples: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("TileGrad", |nd| {
            nd.add_input(input);
            nd.add_input(multiples);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'TileGrad' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        multiples: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<TileGradInst> {
        let op = scope.new_operation("TileGrad", |builder| {
            builder.add_input(input);
            builder.add_input(multiples);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(TileGradInst { op })
    }
}
impl TileGradInst {
    /// Returns the 'output' Output of this 'TileGrad' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'TileGrad' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'multiples' Input of this 'TileGrad' operation.
    pub fn multiples(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<TileGradInst> for crate::Operation {
    fn from(inst: TileGradInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `TileGrad::new().build(input, multiples, scope)`.
pub fn tile_grad<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    input: O0,
    multiples: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    TileGrad::new().build(input, multiples, scope)
}

/// Builder for the `Timestamp` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Timestamp {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Timestamp' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct TimestampInst {
    /// An instance of a fully built Timestamp Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Timestamp {
    /// Creates a new `Timestamp`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Timestamp` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("Timestamp", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Timestamp' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(&self, scope: &mut crate::Scope) -> crate::Result<TimestampInst> {
        let op = scope.new_operation("Timestamp", |builder| ::std::result::Result::Ok(()))?;
        Ok(TimestampInst { op })
    }
}
impl TimestampInst {
    /// Returns the 'ts' Output of this 'Timestamp' operation.
    pub fn ts(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
}
impl From<TimestampInst> for crate::Operation {
    fn from(inst: TimestampInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Timestamp::new().build(scope)`.
pub fn timestamp(scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
    Timestamp::new().build(scope)
}

/// Builder for the `ToBool` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ToBool {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ToBool' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ToBoolInst {
    /// An instance of a fully built ToBool Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ToBool {
    /// Creates a new `ToBool`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ToBool` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ToBool", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ToBool' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ToBoolInst> {
        let op = scope.new_operation("ToBool", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ToBoolInst { op })
    }
}
impl ToBoolInst {
    /// Returns the 'output' Output of this 'ToBool' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'ToBool' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<ToBoolInst> for crate::Operation {
    fn from(inst: ToBoolInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ToBool::new().build(input, scope)`.
pub fn to_bool<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ToBool::new().build(input, scope)
}

/// Builder for the `TopK` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct TopK {
    k: ::std::option::Option<i64>,
    sorted: ::std::option::Option<bool>,
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'TopK' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct TopKInst {
    /// An instance of a fully built TopK Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl TopK {
    /// Creates a new `TopK`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `k` attribute.
    pub fn k<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.k = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `sorted` attribute.
    pub fn sorted<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.sorted = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `TopK` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("TopK", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.k {
                nd.set_attr_int("k", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.sorted {
                nd.set_attr_bool("sorted", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'TopK' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<TopKInst> {
        let op = scope.new_operation("TopK", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.k {
                builder.set_attr_int("k", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.sorted {
                builder.set_attr_bool("sorted", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(TopKInst { op })
    }
}
impl TopKInst {
    /// Returns the 'values' Output of this 'TopK' operation.
    pub fn values(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'indices' Output of this 'TopK' operation.
    pub fn indices(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'input' Input of this 'TopK' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<TopKInst> for crate::Operation {
    fn from(inst: TopKInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `TopK::new().build(input, scope)`.
pub fn top_k<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    TopK::new().build(input, scope)
}

/// Builder for the `TopKUnique` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct TopKUnique {
    k: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'TopKUnique' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct TopKUniqueInst {
    /// An instance of a fully built TopKUnique Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl TopKUnique {
    /// Creates a new `TopKUnique`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `k` attribute.
    pub fn k<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.k = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `TopKUnique` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("TopKUnique", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.k {
                nd.set_attr_int("k", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'TopKUnique' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<TopKUniqueInst> {
        let op = scope.new_operation("TopKUnique", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.k {
                builder.set_attr_int("k", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(TopKUniqueInst { op })
    }
}
impl TopKUniqueInst {
    /// Returns the 'topk' Output of this 'TopKUnique' operation.
    pub fn topk(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'topk_indices' Output of this 'TopKUnique' operation.
    pub fn topk_indices(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'input' Input of this 'TopKUnique' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<TopKUniqueInst> for crate::Operation {
    fn from(inst: TopKUniqueInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `TopKUnique::new().build(input, scope)`.
pub fn top_kunique<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    TopKUnique::new().build(input, scope)
}

/// Builder for the `TopKV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct TopKV2 {
    sorted: ::std::option::Option<bool>,
    T: ::std::option::Option<crate::DataType>,
    Tk: ::std::option::Option<crate::DataType>,
    index_type: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'TopKV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct TopKV2Inst {
    /// An instance of a fully built TopKV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl TopKV2 {
    /// Creates a new `TopKV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `sorted` attribute.
    pub fn sorted<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.sorted = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tk` attribute.
    pub fn Tk<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Tk = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `index_type` attribute.
    pub fn index_type<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.index_type = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `TopKV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        k: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), k.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        k: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("TopKV2", |nd| {
            nd.add_input(input);
            nd.add_input(k);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.sorted {
                nd.set_attr_bool("sorted", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tk {
                nd.set_attr_type("Tk", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.index_type {
                nd.set_attr_type("index_type", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'TopKV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        k: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<TopKV2Inst> {
        let op = scope.new_operation("TopKV2", |builder| {
            builder.add_input(input);
            builder.add_input(k);
            if let ::std::option::Option::Some(value) = &self.sorted {
                builder.set_attr_bool("sorted", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tk {
                builder.set_attr_type("Tk", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.index_type {
                builder.set_attr_type("index_type", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(TopKV2Inst { op })
    }
}
impl TopKV2Inst {
    /// Returns the 'values' Output of this 'TopKV2' operation.
    pub fn values(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'indices' Output of this 'TopKV2' operation.
    pub fn indices(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'input' Input of this 'TopKV2' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'k' Input of this 'TopKV2' operation.
    pub fn k(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<TopKV2Inst> for crate::Operation {
    fn from(inst: TopKV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `TopKV2::new().build(input, k, scope)`.
pub fn top_kv2<O0: ::std::convert::Into<crate::Output>, O1: ::std::convert::Into<crate::Output>>(
    input: O0,
    k: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    TopKV2::new().build(input, k, scope)
}

/// Builder for the `TopKWithUnique` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct TopKWithUnique {
    k: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'TopKWithUnique' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct TopKWithUniqueInst {
    /// An instance of a fully built TopKWithUnique Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl TopKWithUnique {
    /// Creates a new `TopKWithUnique`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `k` attribute.
    pub fn k<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.k = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `TopKWithUnique` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("TopKWithUnique", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.k {
                nd.set_attr_int("k", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'TopKWithUnique' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<TopKWithUniqueInst> {
        let op = scope.new_operation("TopKWithUnique", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.k {
                builder.set_attr_int("k", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(TopKWithUniqueInst { op })
    }
}
impl TopKWithUniqueInst {
    /// Returns the 'topk' Output of this 'TopKWithUnique' operation.
    pub fn topk(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'topk_indices' Output of this 'TopKWithUnique' operation.
    pub fn topk_indices(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'input' Input of this 'TopKWithUnique' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<TopKWithUniqueInst> for crate::Operation {
    fn from(inst: TopKWithUniqueInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `TopKWithUnique::new().build(input, scope)`.
pub fn top_kwith_unique<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    TopKWithUnique::new().build(input, scope)
}

/// Builder for the `TpuHandleToProtoKey` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct TpuHandleToProtoKey {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'TpuHandleToProtoKey' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct TpuHandleToProtoKeyInst {
    /// An instance of a fully built TpuHandleToProtoKey Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl TpuHandleToProtoKey {
    /// Creates a new `TpuHandleToProtoKey`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `TpuHandleToProtoKey` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        uid: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(uid.into(), scope)
    }
    fn build_impl(
        &self,
        uid: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("TpuHandleToProtoKey", |nd| {
            nd.add_input(uid);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'TpuHandleToProtoKey' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        uid: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<TpuHandleToProtoKeyInst> {
        let op = scope.new_operation("TpuHandleToProtoKey", |builder| {
            builder.add_input(uid);
            ::std::result::Result::Ok(())
        })?;
        Ok(TpuHandleToProtoKeyInst { op })
    }
}
impl TpuHandleToProtoKeyInst {
    /// Returns the 'proto_keys' Output of this 'TpuHandleToProtoKey' operation.
    pub fn proto_keys(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'uid' Input of this 'TpuHandleToProtoKey' operation.
    pub fn uid(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<TpuHandleToProtoKeyInst> for crate::Operation {
    fn from(inst: TpuHandleToProtoKeyInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `TpuHandleToProtoKey::new().build(uid, scope)`.
pub fn tpu_handle_to_proto_key<O0: ::std::convert::Into<crate::Output>>(
    uid: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    TpuHandleToProtoKey::new().build(uid, scope)
}

/// Builder for the `Transpose` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Transpose {
    T: ::std::option::Option<crate::DataType>,
    Tperm: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Transpose' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct TransposeInst {
    /// An instance of a fully built Transpose Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Transpose {
    /// Creates a new `Transpose`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tperm` attribute.
    pub fn Tperm<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Tperm = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Transpose` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        x: O0,
        perm: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), perm.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        perm: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Transpose", |nd| {
            nd.add_input(x);
            nd.add_input(perm);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tperm {
                nd.set_attr_type("Tperm", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Transpose' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        perm: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<TransposeInst> {
        let op = scope.new_operation("Transpose", |builder| {
            builder.add_input(x);
            builder.add_input(perm);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tperm {
                builder.set_attr_type("Tperm", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(TransposeInst { op })
    }
}
impl TransposeInst {
    /// Returns the 'y' Output of this 'Transpose' operation.
    pub fn y(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'Transpose' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'perm' Input of this 'Transpose' operation.
    pub fn perm(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<TransposeInst> for crate::Operation {
    fn from(inst: TransposeInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Transpose::new().build(x, perm, scope)`.
pub fn transpose<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    x: O0,
    perm: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Transpose::new().build(x, perm, scope)
}

/// Builder for the `TridiagonalMatMul` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct TridiagonalMatMul {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'TridiagonalMatMul' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct TridiagonalMatMulInst {
    /// An instance of a fully built TridiagonalMatMul Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl TridiagonalMatMul {
    /// Creates a new `TridiagonalMatMul`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `TridiagonalMatMul` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
    >(
        &self,
        superdiag: O0,
        maindiag: O1,
        subdiag: O2,
        rhs: O3,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            superdiag.into(),
            maindiag.into(),
            subdiag.into(),
            rhs.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        superdiag: crate::Output,
        maindiag: crate::Output,
        subdiag: crate::Output,
        rhs: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("TridiagonalMatMul", |nd| {
            nd.add_input(superdiag);
            nd.add_input(maindiag);
            nd.add_input(subdiag);
            nd.add_input(rhs);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'TridiagonalMatMul' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        superdiag: crate::Output,
        maindiag: crate::Output,
        subdiag: crate::Output,
        rhs: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<TridiagonalMatMulInst> {
        let op = scope.new_operation("TridiagonalMatMul", |builder| {
            builder.add_input(superdiag);
            builder.add_input(maindiag);
            builder.add_input(subdiag);
            builder.add_input(rhs);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(TridiagonalMatMulInst { op })
    }
}
impl TridiagonalMatMulInst {
    /// Returns the 'output' Output of this 'TridiagonalMatMul' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'superdiag' Input of this 'TridiagonalMatMul' operation.
    pub fn superdiag(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'maindiag' Input of this 'TridiagonalMatMul' operation.
    pub fn maindiag(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'subdiag' Input of this 'TridiagonalMatMul' operation.
    pub fn subdiag(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'rhs' Input of this 'TridiagonalMatMul' operation.
    pub fn rhs(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
}
impl From<TridiagonalMatMulInst> for crate::Operation {
    fn from(inst: TridiagonalMatMulInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `TridiagonalMatMul::new().build(superdiag, maindiag, subdiag, rhs, scope)`.
pub fn tridiagonal_mat_mul<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
>(
    superdiag: O0,
    maindiag: O1,
    subdiag: O2,
    rhs: O3,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    TridiagonalMatMul::new().build(superdiag, maindiag, subdiag, rhs, scope)
}

/// Builder for the `TridiagonalSolve` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct TridiagonalSolve {
    partial_pivoting: ::std::option::Option<bool>,
    perturb_singular: ::std::option::Option<bool>,
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'TridiagonalSolve' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct TridiagonalSolveInst {
    /// An instance of a fully built TridiagonalSolve Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl TridiagonalSolve {
    /// Creates a new `TridiagonalSolve`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `partial_pivoting` attribute.
    pub fn partial_pivoting<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.partial_pivoting = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `perturb_singular` attribute.
    pub fn perturb_singular<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.perturb_singular = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `TridiagonalSolve` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        diagonals: O0,
        rhs: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(diagonals.into(), rhs.into(), scope)
    }
    fn build_impl(
        &self,
        diagonals: crate::Output,
        rhs: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("TridiagonalSolve", |nd| {
            nd.add_input(diagonals);
            nd.add_input(rhs);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.partial_pivoting {
                nd.set_attr_bool("partial_pivoting", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.perturb_singular {
                nd.set_attr_bool("perturb_singular", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'TridiagonalSolve' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        diagonals: crate::Output,
        rhs: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<TridiagonalSolveInst> {
        let op = scope.new_operation("TridiagonalSolve", |builder| {
            builder.add_input(diagonals);
            builder.add_input(rhs);
            if let ::std::option::Option::Some(value) = &self.partial_pivoting {
                builder.set_attr_bool("partial_pivoting", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.perturb_singular {
                builder.set_attr_bool("perturb_singular", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(TridiagonalSolveInst { op })
    }
}
impl TridiagonalSolveInst {
    /// Returns the 'output' Output of this 'TridiagonalSolve' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'diagonals' Input of this 'TridiagonalSolve' operation.
    pub fn diagonals(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'rhs' Input of this 'TridiagonalSolve' operation.
    pub fn rhs(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<TridiagonalSolveInst> for crate::Operation {
    fn from(inst: TridiagonalSolveInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `TridiagonalSolve::new().build(diagonals, rhs, scope)`.
pub fn tridiagonal_solve<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    diagonals: O0,
    rhs: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    TridiagonalSolve::new().build(diagonals, rhs, scope)
}

/// Builder for the `TruncateDiv` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct TruncateDiv {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'TruncateDiv' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct TruncateDivInst {
    /// An instance of a fully built TruncateDiv Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl TruncateDiv {
    /// Creates a new `TruncateDiv`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `TruncateDiv` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        x: O0,
        y: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), y.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        y: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("TruncateDiv", |nd| {
            nd.add_input(x);
            nd.add_input(y);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'TruncateDiv' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        y: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<TruncateDivInst> {
        let op = scope.new_operation("TruncateDiv", |builder| {
            builder.add_input(x);
            builder.add_input(y);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(TruncateDivInst { op })
    }
}
impl TruncateDivInst {
    /// Returns the 'z' Output of this 'TruncateDiv' operation.
    pub fn z(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'TruncateDiv' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'y' Input of this 'TruncateDiv' operation.
    pub fn y(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<TruncateDivInst> for crate::Operation {
    fn from(inst: TruncateDivInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `TruncateDiv::new().build(x, y, scope)`.
pub fn truncate_div<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    x: O0,
    y: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    TruncateDiv::new().build(x, y, scope)
}

/// Builder for the `TruncateMod` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct TruncateMod {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'TruncateMod' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct TruncateModInst {
    /// An instance of a fully built TruncateMod Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl TruncateMod {
    /// Creates a new `TruncateMod`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `TruncateMod` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        x: O0,
        y: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), y.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        y: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("TruncateMod", |nd| {
            nd.add_input(x);
            nd.add_input(y);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'TruncateMod' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        y: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<TruncateModInst> {
        let op = scope.new_operation("TruncateMod", |builder| {
            builder.add_input(x);
            builder.add_input(y);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(TruncateModInst { op })
    }
}
impl TruncateModInst {
    /// Returns the 'z' Output of this 'TruncateMod' operation.
    pub fn z(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'TruncateMod' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'y' Input of this 'TruncateMod' operation.
    pub fn y(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<TruncateModInst> for crate::Operation {
    fn from(inst: TruncateModInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `TruncateMod::new().build(x, y, scope)`.
pub fn truncate_mod<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    x: O0,
    y: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    TruncateMod::new().build(x, y, scope)
}

/// Builder for the `TruncatedNormal` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct TruncatedNormal {
    seed: ::std::option::Option<i64>,
    seed2: ::std::option::Option<i64>,
    dtype: ::std::option::Option<crate::DataType>,
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'TruncatedNormal' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct TruncatedNormalInst {
    /// An instance of a fully built TruncatedNormal Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl TruncatedNormal {
    /// Creates a new `TruncatedNormal`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `seed` attribute.
    pub fn seed<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.seed = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `seed2` attribute.
    pub fn seed2<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.seed2 = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `dtype` attribute.
    pub fn dtype<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `TruncatedNormal` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        shape: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(shape.into(), scope)
    }
    fn build_impl(
        &self,
        shape: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("TruncatedNormal", |nd| {
            nd.add_input(shape);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.seed {
                nd.set_attr_int("seed", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed2 {
                nd.set_attr_int("seed2", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                nd.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'TruncatedNormal' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        shape: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<TruncatedNormalInst> {
        let op = scope.new_operation("TruncatedNormal", |builder| {
            builder.add_input(shape);
            if let ::std::option::Option::Some(value) = &self.seed {
                builder.set_attr_int("seed", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed2 {
                builder.set_attr_int("seed2", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                builder.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(TruncatedNormalInst { op })
    }
}
impl TruncatedNormalInst {
    /// Returns the 'output' Output of this 'TruncatedNormal' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'shape' Input of this 'TruncatedNormal' operation.
    pub fn shape(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<TruncatedNormalInst> for crate::Operation {
    fn from(inst: TruncatedNormalInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `TruncatedNormal::new().build(shape, scope)`.
pub fn truncated_normal<O0: ::std::convert::Into<crate::Output>>(
    shape: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    TruncatedNormal::new().build(shape, scope)
}

/// Builder for the `Unbatch` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Unbatch {
    timeout_micros: ::std::option::Option<i64>,
    container: ::std::option::Option<::std::string::String>,
    shared_name: ::std::option::Option<::std::string::String>,
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Unbatch' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct UnbatchInst {
    /// An instance of a fully built Unbatch Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Unbatch {
    /// Creates a new `Unbatch`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `timeout_micros` attribute.
    pub fn timeout_micros<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.timeout_micros = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `container` attribute.
    pub fn container<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.container = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shared_name` attribute.
    pub fn shared_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.shared_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Unbatch` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        batched_tensor: O0,
        batch_index: O1,
        id: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(batched_tensor.into(), batch_index.into(), id.into(), scope)
    }
    fn build_impl(
        &self,
        batched_tensor: crate::Output,
        batch_index: crate::Output,
        id: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Unbatch", |nd| {
            nd.add_input(batched_tensor);
            nd.add_input(batch_index);
            nd.add_input(id);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.timeout_micros {
                nd.set_attr_int("timeout_micros", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.container {
                nd.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                nd.set_attr_string("shared_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Unbatch' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        batched_tensor: crate::Output,
        batch_index: crate::Output,
        id: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<UnbatchInst> {
        let op = scope.new_operation("Unbatch", |builder| {
            builder.add_input(batched_tensor);
            builder.add_input(batch_index);
            builder.add_input(id);
            if let ::std::option::Option::Some(value) = &self.timeout_micros {
                builder.set_attr_int("timeout_micros", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.container {
                builder.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                builder.set_attr_string("shared_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(UnbatchInst { op })
    }
}
impl UnbatchInst {
    /// Returns the 'unbatched_tensor' Output of this 'Unbatch' operation.
    pub fn unbatched_tensor(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'batched_tensor' Input of this 'Unbatch' operation.
    pub fn batched_tensor(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'batch_index' Input of this 'Unbatch' operation.
    pub fn batch_index(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'id' Input of this 'Unbatch' operation.
    pub fn id(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<UnbatchInst> for crate::Operation {
    fn from(inst: UnbatchInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Unbatch::new().build(batched_tensor, batch_index, id, scope)`.
pub fn unbatch<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    batched_tensor: O0,
    batch_index: O1,
    id: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Unbatch::new().build(batched_tensor, batch_index, id, scope)
}

/// Builder for the `UnbatchDataset` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct UnbatchDataset {
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    metadata: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'UnbatchDataset' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct UnbatchDatasetInst {
    /// An instance of a fully built UnbatchDataset Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl UnbatchDataset {
    /// Creates a new `UnbatchDataset`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `metadata` attribute.
    pub fn metadata<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.metadata = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `UnbatchDataset` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input_dataset: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input_dataset.into(), scope)
    }
    fn build_impl(
        &self,
        input_dataset: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("UnbatchDataset", |nd| {
            nd.add_input(input_dataset);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.metadata {
                nd.set_attr_string("metadata", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'UnbatchDataset' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_dataset: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<UnbatchDatasetInst> {
        let op = scope.new_operation("UnbatchDataset", |builder| {
            builder.add_input(input_dataset);
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.metadata {
                builder.set_attr_string("metadata", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(UnbatchDatasetInst { op })
    }
}
impl UnbatchDatasetInst {
    /// Returns the 'handle' Output of this 'UnbatchDataset' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_dataset' Input of this 'UnbatchDataset' operation.
    pub fn input_dataset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<UnbatchDatasetInst> for crate::Operation {
    fn from(inst: UnbatchDatasetInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `UnbatchDataset::new().build(input_dataset, scope)`.
pub fn unbatch_dataset<O0: ::std::convert::Into<crate::Output>>(
    input_dataset: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    UnbatchDataset::new().build(input_dataset, scope)
}

/// Builder for the `UnbatchGrad` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct UnbatchGrad {
    container: ::std::option::Option<::std::string::String>,
    shared_name: ::std::option::Option<::std::string::String>,
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'UnbatchGrad' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct UnbatchGradInst {
    /// An instance of a fully built UnbatchGrad Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl UnbatchGrad {
    /// Creates a new `UnbatchGrad`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `container` attribute.
    pub fn container<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.container = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shared_name` attribute.
    pub fn shared_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.shared_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `UnbatchGrad` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
    >(
        &self,
        original_input: O0,
        batch_index: O1,
        grad: O2,
        id: O3,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            original_input.into(),
            batch_index.into(),
            grad.into(),
            id.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        original_input: crate::Output,
        batch_index: crate::Output,
        grad: crate::Output,
        id: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("UnbatchGrad", |nd| {
            nd.add_input(original_input);
            nd.add_input(batch_index);
            nd.add_input(grad);
            nd.add_input(id);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.container {
                nd.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                nd.set_attr_string("shared_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'UnbatchGrad' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        original_input: crate::Output,
        batch_index: crate::Output,
        grad: crate::Output,
        id: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<UnbatchGradInst> {
        let op = scope.new_operation("UnbatchGrad", |builder| {
            builder.add_input(original_input);
            builder.add_input(batch_index);
            builder.add_input(grad);
            builder.add_input(id);
            if let ::std::option::Option::Some(value) = &self.container {
                builder.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                builder.set_attr_string("shared_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(UnbatchGradInst { op })
    }
}
impl UnbatchGradInst {
    /// Returns the 'batched_grad' Output of this 'UnbatchGrad' operation.
    pub fn batched_grad(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'original_input' Input of this 'UnbatchGrad' operation.
    pub fn original_input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'batch_index' Input of this 'UnbatchGrad' operation.
    pub fn batch_index(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'grad' Input of this 'UnbatchGrad' operation.
    pub fn grad(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'id' Input of this 'UnbatchGrad' operation.
    pub fn id(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
}
impl From<UnbatchGradInst> for crate::Operation {
    fn from(inst: UnbatchGradInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `UnbatchGrad::new().build(original_input, batch_index, grad, id, scope)`.
pub fn unbatch_grad<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
>(
    original_input: O0,
    batch_index: O1,
    grad: O2,
    id: O3,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    UnbatchGrad::new().build(original_input, batch_index, grad, id, scope)
}

/// Builder for the `UncompressElement` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct UncompressElement {
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'UncompressElement' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct UncompressElementInst {
    /// An instance of a fully built UncompressElement Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl UncompressElement {
    /// Creates a new `UncompressElement`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `UncompressElement` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        compressed: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(compressed.into(), scope)
    }
    fn build_impl(
        &self,
        compressed: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("UncompressElement", |nd| {
            nd.add_input(compressed);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'UncompressElement' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        compressed: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<UncompressElementInst> {
        let op = scope.new_operation("UncompressElement", |builder| {
            builder.add_input(compressed);
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(UncompressElementInst { op })
    }
}
impl UncompressElementInst {
    /// Returns the 'components' Output of this 'UncompressElement' operation.
    pub fn components(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'compressed' Input of this 'UncompressElement' operation.
    pub fn compressed(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<UncompressElementInst> for crate::Operation {
    fn from(inst: UncompressElementInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `UncompressElement::new().build(compressed, scope)`.
pub fn uncompress_element<O0: ::std::convert::Into<crate::Output>>(
    compressed: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    UncompressElement::new().build(compressed, scope)
}

/// Builder for the `UnicodeDecode` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct UnicodeDecode {
    input_encoding: ::std::option::Option<::std::string::String>,
    errors: ::std::option::Option<::std::string::String>,
    replacement_char: ::std::option::Option<i64>,
    replace_control_characters: ::std::option::Option<bool>,
    Tsplits: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'UnicodeDecode' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct UnicodeDecodeInst {
    /// An instance of a fully built UnicodeDecode Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl UnicodeDecode {
    /// Creates a new `UnicodeDecode`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `input_encoding` attribute.
    pub fn input_encoding<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.input_encoding = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `errors` attribute.
    pub fn errors<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.errors = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `replacement_char` attribute.
    pub fn replacement_char<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.replacement_char = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `replace_control_characters` attribute.
    pub fn replace_control_characters<ArgType: ::std::convert::Into<bool>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.replace_control_characters = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tsplits` attribute.
    pub fn Tsplits<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tsplits = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `UnicodeDecode` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("UnicodeDecode", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.input_encoding {
                nd.set_attr_string("input_encoding", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.errors {
                nd.set_attr_string("errors", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.replacement_char {
                nd.set_attr_int("replacement_char", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.replace_control_characters {
                nd.set_attr_bool("replace_control_characters", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tsplits {
                nd.set_attr_type("Tsplits", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'UnicodeDecode' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<UnicodeDecodeInst> {
        let op = scope.new_operation("UnicodeDecode", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.input_encoding {
                builder.set_attr_string("input_encoding", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.errors {
                builder.set_attr_string("errors", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.replacement_char {
                builder.set_attr_int("replacement_char", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.replace_control_characters {
                builder.set_attr_bool("replace_control_characters", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tsplits {
                builder.set_attr_type("Tsplits", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(UnicodeDecodeInst { op })
    }
}
impl UnicodeDecodeInst {
    /// Returns the 'row_splits' Output of this 'UnicodeDecode' operation.
    pub fn row_splits(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'char_values' Output of this 'UnicodeDecode' operation.
    pub fn char_values(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'input' Input of this 'UnicodeDecode' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<UnicodeDecodeInst> for crate::Operation {
    fn from(inst: UnicodeDecodeInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `UnicodeDecode::new().build(input, scope)`.
pub fn unicode_decode<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    UnicodeDecode::new().build(input, scope)
}

/// Builder for the `UnicodeDecodeWithOffsets` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct UnicodeDecodeWithOffsets {
    input_encoding: ::std::option::Option<::std::string::String>,
    errors: ::std::option::Option<::std::string::String>,
    replacement_char: ::std::option::Option<i64>,
    replace_control_characters: ::std::option::Option<bool>,
    Tsplits: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'UnicodeDecodeWithOffsets' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct UnicodeDecodeWithOffsetsInst {
    /// An instance of a fully built UnicodeDecodeWithOffsets Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl UnicodeDecodeWithOffsets {
    /// Creates a new `UnicodeDecodeWithOffsets`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `input_encoding` attribute.
    pub fn input_encoding<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.input_encoding = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `errors` attribute.
    pub fn errors<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.errors = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `replacement_char` attribute.
    pub fn replacement_char<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.replacement_char = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `replace_control_characters` attribute.
    pub fn replace_control_characters<ArgType: ::std::convert::Into<bool>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.replace_control_characters = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tsplits` attribute.
    pub fn Tsplits<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tsplits = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `UnicodeDecodeWithOffsets` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("UnicodeDecodeWithOffsets", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.input_encoding {
                nd.set_attr_string("input_encoding", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.errors {
                nd.set_attr_string("errors", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.replacement_char {
                nd.set_attr_int("replacement_char", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.replace_control_characters {
                nd.set_attr_bool("replace_control_characters", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tsplits {
                nd.set_attr_type("Tsplits", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'UnicodeDecodeWithOffsets' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<UnicodeDecodeWithOffsetsInst> {
        let op = scope.new_operation("UnicodeDecodeWithOffsets", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.input_encoding {
                builder.set_attr_string("input_encoding", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.errors {
                builder.set_attr_string("errors", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.replacement_char {
                builder.set_attr_int("replacement_char", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.replace_control_characters {
                builder.set_attr_bool("replace_control_characters", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tsplits {
                builder.set_attr_type("Tsplits", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(UnicodeDecodeWithOffsetsInst { op })
    }
}
impl UnicodeDecodeWithOffsetsInst {
    /// Returns the 'row_splits' Output of this 'UnicodeDecodeWithOffsets' operation.
    pub fn row_splits(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'char_values' Output of this 'UnicodeDecodeWithOffsets' operation.
    pub fn char_values(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'char_to_byte_starts' Output of this 'UnicodeDecodeWithOffsets' operation.
    pub fn char_to_byte_starts(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns the 'input' Input of this 'UnicodeDecodeWithOffsets' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<UnicodeDecodeWithOffsetsInst> for crate::Operation {
    fn from(inst: UnicodeDecodeWithOffsetsInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `UnicodeDecodeWithOffsets::new().build(input, scope)`.
pub fn unicode_decode_with_offsets<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    UnicodeDecodeWithOffsets::new().build(input, scope)
}

/// Builder for the `UnicodeEncode` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct UnicodeEncode {
    errors: ::std::option::Option<::std::string::String>,
    output_encoding: ::std::option::Option<::std::string::String>,
    replacement_char: ::std::option::Option<i64>,
    Tsplits: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'UnicodeEncode' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct UnicodeEncodeInst {
    /// An instance of a fully built UnicodeEncode Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl UnicodeEncode {
    /// Creates a new `UnicodeEncode`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `errors` attribute.
    pub fn errors<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.errors = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_encoding` attribute.
    pub fn output_encoding<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_encoding = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `replacement_char` attribute.
    pub fn replacement_char<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.replacement_char = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tsplits` attribute.
    pub fn Tsplits<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tsplits = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `UnicodeEncode` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input_values: O0,
        input_splits: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input_values.into(), input_splits.into(), scope)
    }
    fn build_impl(
        &self,
        input_values: crate::Output,
        input_splits: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("UnicodeEncode", |nd| {
            nd.add_input(input_values);
            nd.add_input(input_splits);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.errors {
                nd.set_attr_string("errors", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_encoding {
                nd.set_attr_string("output_encoding", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.replacement_char {
                nd.set_attr_int("replacement_char", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tsplits {
                nd.set_attr_type("Tsplits", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'UnicodeEncode' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_values: crate::Output,
        input_splits: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<UnicodeEncodeInst> {
        let op = scope.new_operation("UnicodeEncode", |builder| {
            builder.add_input(input_values);
            builder.add_input(input_splits);
            if let ::std::option::Option::Some(value) = &self.errors {
                builder.set_attr_string("errors", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_encoding {
                builder.set_attr_string("output_encoding", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.replacement_char {
                builder.set_attr_int("replacement_char", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tsplits {
                builder.set_attr_type("Tsplits", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(UnicodeEncodeInst { op })
    }
}
impl UnicodeEncodeInst {
    /// Returns the 'output' Output of this 'UnicodeEncode' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_values' Input of this 'UnicodeEncode' operation.
    pub fn input_values(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'input_splits' Input of this 'UnicodeEncode' operation.
    pub fn input_splits(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<UnicodeEncodeInst> for crate::Operation {
    fn from(inst: UnicodeEncodeInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `UnicodeEncode::new().build(input_values, input_splits, scope)`.
pub fn unicode_encode<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    input_values: O0,
    input_splits: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    UnicodeEncode::new().build(input_values, input_splits, scope)
}

/// Builder for the `UnicodeScript` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct UnicodeScript {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'UnicodeScript' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct UnicodeScriptInst {
    /// An instance of a fully built UnicodeScript Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl UnicodeScript {
    /// Creates a new `UnicodeScript`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `UnicodeScript` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("UnicodeScript", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'UnicodeScript' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<UnicodeScriptInst> {
        let op = scope.new_operation("UnicodeScript", |builder| {
            builder.add_input(input);
            ::std::result::Result::Ok(())
        })?;
        Ok(UnicodeScriptInst { op })
    }
}
impl UnicodeScriptInst {
    /// Returns the 'output' Output of this 'UnicodeScript' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'UnicodeScript' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<UnicodeScriptInst> for crate::Operation {
    fn from(inst: UnicodeScriptInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `UnicodeScript::new().build(input, scope)`.
pub fn unicode_script<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    UnicodeScript::new().build(input, scope)
}

/// Builder for the `UnicodeTranscode` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct UnicodeTranscode {
    input_encoding: ::std::option::Option<::std::string::String>,
    output_encoding: ::std::option::Option<::std::string::String>,
    errors: ::std::option::Option<::std::string::String>,
    replacement_char: ::std::option::Option<i64>,
    replace_control_characters: ::std::option::Option<bool>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'UnicodeTranscode' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct UnicodeTranscodeInst {
    /// An instance of a fully built UnicodeTranscode Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl UnicodeTranscode {
    /// Creates a new `UnicodeTranscode`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `input_encoding` attribute.
    pub fn input_encoding<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.input_encoding = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_encoding` attribute.
    pub fn output_encoding<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_encoding = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `errors` attribute.
    pub fn errors<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.errors = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `replacement_char` attribute.
    pub fn replacement_char<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.replacement_char = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `replace_control_characters` attribute.
    pub fn replace_control_characters<ArgType: ::std::convert::Into<bool>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.replace_control_characters = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `UnicodeTranscode` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("UnicodeTranscode", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.input_encoding {
                nd.set_attr_string("input_encoding", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_encoding {
                nd.set_attr_string("output_encoding", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.errors {
                nd.set_attr_string("errors", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.replacement_char {
                nd.set_attr_int("replacement_char", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.replace_control_characters {
                nd.set_attr_bool("replace_control_characters", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'UnicodeTranscode' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<UnicodeTranscodeInst> {
        let op = scope.new_operation("UnicodeTranscode", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.input_encoding {
                builder.set_attr_string("input_encoding", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_encoding {
                builder.set_attr_string("output_encoding", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.errors {
                builder.set_attr_string("errors", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.replacement_char {
                builder.set_attr_int("replacement_char", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.replace_control_characters {
                builder.set_attr_bool("replace_control_characters", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(UnicodeTranscodeInst { op })
    }
}
impl UnicodeTranscodeInst {
    /// Returns the 'output' Output of this 'UnicodeTranscode' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'UnicodeTranscode' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<UnicodeTranscodeInst> for crate::Operation {
    fn from(inst: UnicodeTranscodeInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `UnicodeTranscode::new().build(input, scope)`.
pub fn unicode_transcode<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    UnicodeTranscode::new().build(input, scope)
}

/// Builder for the `UniformCandidateSampler` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct UniformCandidateSampler {
    num_true: ::std::option::Option<i64>,
    num_sampled: ::std::option::Option<i64>,
    unique: ::std::option::Option<bool>,
    range_max: ::std::option::Option<i64>,
    seed: ::std::option::Option<i64>,
    seed2: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'UniformCandidateSampler' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct UniformCandidateSamplerInst {
    /// An instance of a fully built UniformCandidateSampler Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl UniformCandidateSampler {
    /// Creates a new `UniformCandidateSampler`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `num_true` attribute.
    pub fn num_true<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.num_true = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `num_sampled` attribute.
    pub fn num_sampled<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.num_sampled = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `unique` attribute.
    pub fn unique<ArgType: ::std::convert::Into<bool>>(mut self, value: ArgType) -> Self {
        self.unique = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `range_max` attribute.
    pub fn range_max<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.range_max = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `seed` attribute.
    pub fn seed<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.seed = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `seed2` attribute.
    pub fn seed2<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.seed2 = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `UniformCandidateSampler` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        true_classes: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(true_classes.into(), scope)
    }
    fn build_impl(
        &self,
        true_classes: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("UniformCandidateSampler", |nd| {
            nd.add_input(true_classes);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.num_true {
                nd.set_attr_int("num_true", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_sampled {
                nd.set_attr_int("num_sampled", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.unique {
                nd.set_attr_bool("unique", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.range_max {
                nd.set_attr_int("range_max", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed {
                nd.set_attr_int("seed", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed2 {
                nd.set_attr_int("seed2", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'UniformCandidateSampler' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        true_classes: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<UniformCandidateSamplerInst> {
        let op = scope.new_operation("UniformCandidateSampler", |builder| {
            builder.add_input(true_classes);
            if let ::std::option::Option::Some(value) = &self.num_true {
                builder.set_attr_int("num_true", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_sampled {
                builder.set_attr_int("num_sampled", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.unique {
                builder.set_attr_bool("unique", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.range_max {
                builder.set_attr_int("range_max", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed {
                builder.set_attr_int("seed", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.seed2 {
                builder.set_attr_int("seed2", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(UniformCandidateSamplerInst { op })
    }
}
impl UniformCandidateSamplerInst {
    /// Returns the 'sampled_candidates' Output of this 'UniformCandidateSampler' operation.
    pub fn sampled_candidates(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'true_expected_count' Output of this 'UniformCandidateSampler' operation.
    pub fn true_expected_count(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'sampled_expected_count' Output of this 'UniformCandidateSampler' operation.
    pub fn sampled_expected_count(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns the 'true_classes' Input of this 'UniformCandidateSampler' operation.
    pub fn true_classes(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<UniformCandidateSamplerInst> for crate::Operation {
    fn from(inst: UniformCandidateSamplerInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `UniformCandidateSampler::new().build(true_classes, scope)`.
pub fn uniform_candidate_sampler<O0: ::std::convert::Into<crate::Output>>(
    true_classes: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    UniformCandidateSampler::new().build(true_classes, scope)
}

/// Builder for the `UniformDequantize` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct UniformDequantize {
    Tin: ::std::option::Option<crate::DataType>,
    Tout: ::std::option::Option<crate::DataType>,
    quantization_axis: ::std::option::Option<i64>,
    quantization_min_val: ::std::option::Option<i64>,
    quantization_max_val: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'UniformDequantize' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct UniformDequantizeInst {
    /// An instance of a fully built UniformDequantize Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl UniformDequantize {
    /// Creates a new `UniformDequantize`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `Tin` attribute.
    pub fn Tin<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Tin = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tout` attribute.
    pub fn Tout<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Tout = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `quantization_axis` attribute.
    pub fn quantization_axis<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.quantization_axis = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `quantization_min_val` attribute.
    pub fn quantization_min_val<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.quantization_min_val = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `quantization_max_val` attribute.
    pub fn quantization_max_val<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.quantization_max_val = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `UniformDequantize` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        scales: O1,
        zero_points: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scales.into(), zero_points.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scales: crate::Output,
        zero_points: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("UniformDequantize", |nd| {
            nd.add_input(input);
            nd.add_input(scales);
            nd.add_input(zero_points);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.Tin {
                nd.set_attr_type("Tin", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tout {
                nd.set_attr_type("Tout", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.quantization_axis {
                nd.set_attr_int("quantization_axis", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.quantization_min_val {
                nd.set_attr_int("quantization_min_val", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.quantization_max_val {
                nd.set_attr_int("quantization_max_val", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'UniformDequantize' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scales: crate::Output,
        zero_points: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<UniformDequantizeInst> {
        let op = scope.new_operation("UniformDequantize", |builder| {
            builder.add_input(input);
            builder.add_input(scales);
            builder.add_input(zero_points);
            if let ::std::option::Option::Some(value) = &self.Tin {
                builder.set_attr_type("Tin", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tout {
                builder.set_attr_type("Tout", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.quantization_axis {
                builder.set_attr_int("quantization_axis", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.quantization_min_val {
                builder.set_attr_int("quantization_min_val", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.quantization_max_val {
                builder.set_attr_int("quantization_max_val", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(UniformDequantizeInst { op })
    }
}
impl UniformDequantizeInst {
    /// Returns the 'output' Output of this 'UniformDequantize' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'UniformDequantize' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'scales' Input of this 'UniformDequantize' operation.
    pub fn scales(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'zero_points' Input of this 'UniformDequantize' operation.
    pub fn zero_points(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<UniformDequantizeInst> for crate::Operation {
    fn from(inst: UniformDequantizeInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `UniformDequantize::new().build(input, scales, zero_points, scope)`.
pub fn uniform_dequantize<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    input: O0,
    scales: O1,
    zero_points: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    UniformDequantize::new().build(input, scales, zero_points, scope)
}

/// Builder for the `UniformQuantize` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct UniformQuantize {
    Tin: ::std::option::Option<crate::DataType>,
    Tout: ::std::option::Option<crate::DataType>,
    quantization_axis: ::std::option::Option<i64>,
    quantization_min_val: ::std::option::Option<i64>,
    quantization_max_val: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'UniformQuantize' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct UniformQuantizeInst {
    /// An instance of a fully built UniformQuantize Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl UniformQuantize {
    /// Creates a new `UniformQuantize`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `Tin` attribute.
    pub fn Tin<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Tin = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tout` attribute.
    pub fn Tout<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Tout = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `quantization_axis` attribute.
    pub fn quantization_axis<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.quantization_axis = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `quantization_min_val` attribute.
    pub fn quantization_min_val<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.quantization_min_val = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `quantization_max_val` attribute.
    pub fn quantization_max_val<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.quantization_max_val = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `UniformQuantize` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        scales: O1,
        zero_points: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scales.into(), zero_points.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scales: crate::Output,
        zero_points: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("UniformQuantize", |nd| {
            nd.add_input(input);
            nd.add_input(scales);
            nd.add_input(zero_points);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.Tin {
                nd.set_attr_type("Tin", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tout {
                nd.set_attr_type("Tout", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.quantization_axis {
                nd.set_attr_int("quantization_axis", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.quantization_min_val {
                nd.set_attr_int("quantization_min_val", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.quantization_max_val {
                nd.set_attr_int("quantization_max_val", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'UniformQuantize' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scales: crate::Output,
        zero_points: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<UniformQuantizeInst> {
        let op = scope.new_operation("UniformQuantize", |builder| {
            builder.add_input(input);
            builder.add_input(scales);
            builder.add_input(zero_points);
            if let ::std::option::Option::Some(value) = &self.Tin {
                builder.set_attr_type("Tin", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tout {
                builder.set_attr_type("Tout", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.quantization_axis {
                builder.set_attr_int("quantization_axis", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.quantization_min_val {
                builder.set_attr_int("quantization_min_val", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.quantization_max_val {
                builder.set_attr_int("quantization_max_val", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(UniformQuantizeInst { op })
    }
}
impl UniformQuantizeInst {
    /// Returns the 'output' Output of this 'UniformQuantize' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'UniformQuantize' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'scales' Input of this 'UniformQuantize' operation.
    pub fn scales(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'zero_points' Input of this 'UniformQuantize' operation.
    pub fn zero_points(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<UniformQuantizeInst> for crate::Operation {
    fn from(inst: UniformQuantizeInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `UniformQuantize::new().build(input, scales, zero_points, scope)`.
pub fn uniform_quantize<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    input: O0,
    scales: O1,
    zero_points: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    UniformQuantize::new().build(input, scales, zero_points, scope)
}

/// Builder for the `UniformQuantizedAdd` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct UniformQuantizedAdd {
    lhs_quantization_axis: ::std::option::Option<i64>,
    lhs_quantization_min_val: ::std::option::Option<i64>,
    lhs_quantization_max_val: ::std::option::Option<i64>,
    rhs_quantization_axis: ::std::option::Option<i64>,
    rhs_quantization_min_val: ::std::option::Option<i64>,
    rhs_quantization_max_val: ::std::option::Option<i64>,
    output_quantization_axis: ::std::option::Option<i64>,
    output_quantization_min_val: ::std::option::Option<i64>,
    output_quantization_max_val: ::std::option::Option<i64>,
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'UniformQuantizedAdd' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct UniformQuantizedAddInst {
    /// An instance of a fully built UniformQuantizedAdd Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl UniformQuantizedAdd {
    /// Creates a new `UniformQuantizedAdd`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `lhs_quantization_axis` attribute.
    pub fn lhs_quantization_axis<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.lhs_quantization_axis = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `lhs_quantization_min_val` attribute.
    pub fn lhs_quantization_min_val<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.lhs_quantization_min_val = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `lhs_quantization_max_val` attribute.
    pub fn lhs_quantization_max_val<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.lhs_quantization_max_val = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `rhs_quantization_axis` attribute.
    pub fn rhs_quantization_axis<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.rhs_quantization_axis = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `rhs_quantization_min_val` attribute.
    pub fn rhs_quantization_min_val<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.rhs_quantization_min_val = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `rhs_quantization_max_val` attribute.
    pub fn rhs_quantization_max_val<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.rhs_quantization_max_val = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_quantization_axis` attribute.
    pub fn output_quantization_axis<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_quantization_axis = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_quantization_min_val` attribute.
    pub fn output_quantization_min_val<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_quantization_min_val = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_quantization_max_val` attribute.
    pub fn output_quantization_max_val<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_quantization_max_val = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `UniformQuantizedAdd` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
        O6: ::std::convert::Into<crate::Output>,
        O7: ::std::convert::Into<crate::Output>,
    >(
        &self,
        lhs: O0,
        rhs: O1,
        lhs_scales: O2,
        lhs_zero_points: O3,
        rhs_scales: O4,
        rhs_zero_points: O5,
        output_scales: O6,
        output_zero_points: O7,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            lhs.into(),
            rhs.into(),
            lhs_scales.into(),
            lhs_zero_points.into(),
            rhs_scales.into(),
            rhs_zero_points.into(),
            output_scales.into(),
            output_zero_points.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        lhs: crate::Output,
        rhs: crate::Output,
        lhs_scales: crate::Output,
        lhs_zero_points: crate::Output,
        rhs_scales: crate::Output,
        rhs_zero_points: crate::Output,
        output_scales: crate::Output,
        output_zero_points: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("UniformQuantizedAdd", |nd| {
            nd.add_input(lhs);
            nd.add_input(rhs);
            nd.add_input(lhs_scales);
            nd.add_input(lhs_zero_points);
            nd.add_input(rhs_scales);
            nd.add_input(rhs_zero_points);
            nd.add_input(output_scales);
            nd.add_input(output_zero_points);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.lhs_quantization_axis {
                nd.set_attr_int("lhs_quantization_axis", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.lhs_quantization_min_val {
                nd.set_attr_int("lhs_quantization_min_val", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.lhs_quantization_max_val {
                nd.set_attr_int("lhs_quantization_max_val", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.rhs_quantization_axis {
                nd.set_attr_int("rhs_quantization_axis", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.rhs_quantization_min_val {
                nd.set_attr_int("rhs_quantization_min_val", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.rhs_quantization_max_val {
                nd.set_attr_int("rhs_quantization_max_val", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_quantization_axis {
                nd.set_attr_int("output_quantization_axis", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_quantization_min_val {
                nd.set_attr_int("output_quantization_min_val", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_quantization_max_val {
                nd.set_attr_int("output_quantization_max_val", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'UniformQuantizedAdd' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        lhs: crate::Output,
        rhs: crate::Output,
        lhs_scales: crate::Output,
        lhs_zero_points: crate::Output,
        rhs_scales: crate::Output,
        rhs_zero_points: crate::Output,
        output_scales: crate::Output,
        output_zero_points: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<UniformQuantizedAddInst> {
        let op = scope.new_operation("UniformQuantizedAdd", |builder| {
            builder.add_input(lhs);
            builder.add_input(rhs);
            builder.add_input(lhs_scales);
            builder.add_input(lhs_zero_points);
            builder.add_input(rhs_scales);
            builder.add_input(rhs_zero_points);
            builder.add_input(output_scales);
            builder.add_input(output_zero_points);
            if let ::std::option::Option::Some(value) = &self.lhs_quantization_axis {
                builder.set_attr_int("lhs_quantization_axis", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.lhs_quantization_min_val {
                builder.set_attr_int("lhs_quantization_min_val", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.lhs_quantization_max_val {
                builder.set_attr_int("lhs_quantization_max_val", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.rhs_quantization_axis {
                builder.set_attr_int("rhs_quantization_axis", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.rhs_quantization_min_val {
                builder.set_attr_int("rhs_quantization_min_val", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.rhs_quantization_max_val {
                builder.set_attr_int("rhs_quantization_max_val", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_quantization_axis {
                builder.set_attr_int("output_quantization_axis", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_quantization_min_val {
                builder.set_attr_int("output_quantization_min_val", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_quantization_max_val {
                builder.set_attr_int("output_quantization_max_val", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(UniformQuantizedAddInst { op })
    }
}
impl UniformQuantizedAddInst {
    /// Returns the 'output' Output of this 'UniformQuantizedAdd' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'lhs' Input of this 'UniformQuantizedAdd' operation.
    pub fn lhs(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'rhs' Input of this 'UniformQuantizedAdd' operation.
    pub fn rhs(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'lhs_scales' Input of this 'UniformQuantizedAdd' operation.
    pub fn lhs_scales(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'lhs_zero_points' Input of this 'UniformQuantizedAdd' operation.
    pub fn lhs_zero_points(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'rhs_scales' Input of this 'UniformQuantizedAdd' operation.
    pub fn rhs_scales(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
    /// Returns the 'rhs_zero_points' Input of this 'UniformQuantizedAdd' operation.
    pub fn rhs_zero_points(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 5,
        }
    }
    /// Returns the 'output_scales' Input of this 'UniformQuantizedAdd' operation.
    pub fn output_scales(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 6,
        }
    }
    /// Returns the 'output_zero_points' Input of this 'UniformQuantizedAdd' operation.
    pub fn output_zero_points(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 7,
        }
    }
}
impl From<UniformQuantizedAddInst> for crate::Operation {
    fn from(inst: UniformQuantizedAddInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `UniformQuantizedAdd::new().build(lhs, rhs, lhs_scales, lhs_zero_points, rhs_scales, rhs_zero_points, output_scales, output_zero_points, scope)`.
pub fn uniform_quantized_add<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
    O6: ::std::convert::Into<crate::Output>,
    O7: ::std::convert::Into<crate::Output>,
>(
    lhs: O0,
    rhs: O1,
    lhs_scales: O2,
    lhs_zero_points: O3,
    rhs_scales: O4,
    rhs_zero_points: O5,
    output_scales: O6,
    output_zero_points: O7,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    UniformQuantizedAdd::new().build(
        lhs,
        rhs,
        lhs_scales,
        lhs_zero_points,
        rhs_scales,
        rhs_zero_points,
        output_scales,
        output_zero_points,
        scope,
    )
}

/// Builder for the `UniformQuantizedClipByValue` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct UniformQuantizedClipByValue {
    T: ::std::option::Option<crate::DataType>,
    quantization_axis: ::std::option::Option<i64>,
    quantization_min_val: ::std::option::Option<i64>,
    quantization_max_val: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'UniformQuantizedClipByValue' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct UniformQuantizedClipByValueInst {
    /// An instance of a fully built UniformQuantizedClipByValue Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl UniformQuantizedClipByValue {
    /// Creates a new `UniformQuantizedClipByValue`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `quantization_axis` attribute.
    pub fn quantization_axis<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.quantization_axis = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `quantization_min_val` attribute.
    pub fn quantization_min_val<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.quantization_min_val = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `quantization_max_val` attribute.
    pub fn quantization_max_val<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.quantization_max_val = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `UniformQuantizedClipByValue` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
    >(
        &self,
        operand: O0,
        min: O1,
        max: O2,
        scales: O3,
        zero_points: O4,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            operand.into(),
            min.into(),
            max.into(),
            scales.into(),
            zero_points.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        operand: crate::Output,
        min: crate::Output,
        max: crate::Output,
        scales: crate::Output,
        zero_points: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("UniformQuantizedClipByValue", |nd| {
            nd.add_input(operand);
            nd.add_input(min);
            nd.add_input(max);
            nd.add_input(scales);
            nd.add_input(zero_points);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.quantization_axis {
                nd.set_attr_int("quantization_axis", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.quantization_min_val {
                nd.set_attr_int("quantization_min_val", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.quantization_max_val {
                nd.set_attr_int("quantization_max_val", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'UniformQuantizedClipByValue' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        operand: crate::Output,
        min: crate::Output,
        max: crate::Output,
        scales: crate::Output,
        zero_points: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<UniformQuantizedClipByValueInst> {
        let op = scope.new_operation("UniformQuantizedClipByValue", |builder| {
            builder.add_input(operand);
            builder.add_input(min);
            builder.add_input(max);
            builder.add_input(scales);
            builder.add_input(zero_points);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.quantization_axis {
                builder.set_attr_int("quantization_axis", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.quantization_min_val {
                builder.set_attr_int("quantization_min_val", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.quantization_max_val {
                builder.set_attr_int("quantization_max_val", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(UniformQuantizedClipByValueInst { op })
    }
}
impl UniformQuantizedClipByValueInst {
    /// Returns the 'output' Output of this 'UniformQuantizedClipByValue' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'operand' Input of this 'UniformQuantizedClipByValue' operation.
    pub fn operand(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'min' Input of this 'UniformQuantizedClipByValue' operation.
    pub fn min(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'max' Input of this 'UniformQuantizedClipByValue' operation.
    pub fn max(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'scales' Input of this 'UniformQuantizedClipByValue' operation.
    pub fn scales(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'zero_points' Input of this 'UniformQuantizedClipByValue' operation.
    pub fn zero_points(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
}
impl From<UniformQuantizedClipByValueInst> for crate::Operation {
    fn from(inst: UniformQuantizedClipByValueInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `UniformQuantizedClipByValue::new().build(operand, min, max, scales, zero_points, scope)`.
pub fn uniform_quantized_clip_by_value<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
>(
    operand: O0,
    min: O1,
    max: O2,
    scales: O3,
    zero_points: O4,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    UniformQuantizedClipByValue::new().build(operand, min, max, scales, zero_points, scope)
}

/// Builder for the `UniformQuantizedConvolution` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct UniformQuantizedConvolution {
    Tin: ::std::option::Option<crate::DataType>,
    Tout: ::std::option::Option<crate::DataType>,
    window_strides: ::std::option::Option<::std::vec::Vec<i64>>,
    padding: ::std::option::Option<::std::string::String>,
    explicit_padding: ::std::option::Option<::std::vec::Vec<i64>>,
    lhs_dilation: ::std::option::Option<::std::vec::Vec<i64>>,
    rhs_dilation: ::std::option::Option<::std::vec::Vec<i64>>,
    batch_group_count: ::std::option::Option<i64>,
    feature_group_count: ::std::option::Option<i64>,
    dimension_numbers: ::std::option::Option<::std::string::String>,
    lhs_quantization_axis: ::std::option::Option<i64>,
    lhs_quantization_min_val: ::std::option::Option<i64>,
    lhs_quantization_max_val: ::std::option::Option<i64>,
    rhs_quantization_axis: ::std::option::Option<i64>,
    rhs_quantization_min_val: ::std::option::Option<i64>,
    rhs_quantization_max_val: ::std::option::Option<i64>,
    output_quantization_axis: ::std::option::Option<i64>,
    output_quantization_min_val: ::std::option::Option<i64>,
    output_quantization_max_val: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'UniformQuantizedConvolution' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct UniformQuantizedConvolutionInst {
    /// An instance of a fully built UniformQuantizedConvolution Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl UniformQuantizedConvolution {
    /// Creates a new `UniformQuantizedConvolution`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `Tin` attribute.
    pub fn Tin<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Tin = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tout` attribute.
    pub fn Tout<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Tout = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `window_strides` attribute.
    pub fn window_strides<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.window_strides = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `padding` attribute.
    pub fn padding<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.padding = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `explicit_padding` attribute.
    pub fn explicit_padding<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.explicit_padding = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `lhs_dilation` attribute.
    pub fn lhs_dilation<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.lhs_dilation = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `rhs_dilation` attribute.
    pub fn rhs_dilation<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.rhs_dilation = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `batch_group_count` attribute.
    pub fn batch_group_count<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.batch_group_count = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `feature_group_count` attribute.
    pub fn feature_group_count<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.feature_group_count = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `dimension_numbers` attribute.
    pub fn dimension_numbers<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.dimension_numbers = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `lhs_quantization_axis` attribute.
    pub fn lhs_quantization_axis<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.lhs_quantization_axis = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `lhs_quantization_min_val` attribute.
    pub fn lhs_quantization_min_val<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.lhs_quantization_min_val = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `lhs_quantization_max_val` attribute.
    pub fn lhs_quantization_max_val<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.lhs_quantization_max_val = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `rhs_quantization_axis` attribute.
    pub fn rhs_quantization_axis<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.rhs_quantization_axis = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `rhs_quantization_min_val` attribute.
    pub fn rhs_quantization_min_val<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.rhs_quantization_min_val = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `rhs_quantization_max_val` attribute.
    pub fn rhs_quantization_max_val<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.rhs_quantization_max_val = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_quantization_axis` attribute.
    pub fn output_quantization_axis<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_quantization_axis = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_quantization_min_val` attribute.
    pub fn output_quantization_min_val<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_quantization_min_val = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_quantization_max_val` attribute.
    pub fn output_quantization_max_val<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_quantization_max_val = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `UniformQuantizedConvolution` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
        O6: ::std::convert::Into<crate::Output>,
        O7: ::std::convert::Into<crate::Output>,
    >(
        &self,
        lhs: O0,
        rhs: O1,
        lhs_scales: O2,
        lhs_zero_points: O3,
        rhs_scales: O4,
        rhs_zero_points: O5,
        output_scales: O6,
        output_zero_points: O7,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            lhs.into(),
            rhs.into(),
            lhs_scales.into(),
            lhs_zero_points.into(),
            rhs_scales.into(),
            rhs_zero_points.into(),
            output_scales.into(),
            output_zero_points.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        lhs: crate::Output,
        rhs: crate::Output,
        lhs_scales: crate::Output,
        lhs_zero_points: crate::Output,
        rhs_scales: crate::Output,
        rhs_zero_points: crate::Output,
        output_scales: crate::Output,
        output_zero_points: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("UniformQuantizedConvolution", |nd| {
            nd.add_input(lhs);
            nd.add_input(rhs);
            nd.add_input(lhs_scales);
            nd.add_input(lhs_zero_points);
            nd.add_input(rhs_scales);
            nd.add_input(rhs_zero_points);
            nd.add_input(output_scales);
            nd.add_input(output_zero_points);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.Tin {
                nd.set_attr_type("Tin", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tout {
                nd.set_attr_type("Tout", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.window_strides {
                nd.set_attr_int_list("window_strides", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding {
                nd.set_attr_string("padding", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.explicit_padding {
                nd.set_attr_int_list("explicit_padding", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.lhs_dilation {
                nd.set_attr_int_list("lhs_dilation", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.rhs_dilation {
                nd.set_attr_int_list("rhs_dilation", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.batch_group_count {
                nd.set_attr_int("batch_group_count", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.feature_group_count {
                nd.set_attr_int("feature_group_count", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dimension_numbers {
                nd.set_attr_string("dimension_numbers", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.lhs_quantization_axis {
                nd.set_attr_int("lhs_quantization_axis", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.lhs_quantization_min_val {
                nd.set_attr_int("lhs_quantization_min_val", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.lhs_quantization_max_val {
                nd.set_attr_int("lhs_quantization_max_val", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.rhs_quantization_axis {
                nd.set_attr_int("rhs_quantization_axis", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.rhs_quantization_min_val {
                nd.set_attr_int("rhs_quantization_min_val", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.rhs_quantization_max_val {
                nd.set_attr_int("rhs_quantization_max_val", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_quantization_axis {
                nd.set_attr_int("output_quantization_axis", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_quantization_min_val {
                nd.set_attr_int("output_quantization_min_val", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_quantization_max_val {
                nd.set_attr_int("output_quantization_max_val", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'UniformQuantizedConvolution' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        lhs: crate::Output,
        rhs: crate::Output,
        lhs_scales: crate::Output,
        lhs_zero_points: crate::Output,
        rhs_scales: crate::Output,
        rhs_zero_points: crate::Output,
        output_scales: crate::Output,
        output_zero_points: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<UniformQuantizedConvolutionInst> {
        let op = scope.new_operation("UniformQuantizedConvolution", |builder| {
            builder.add_input(lhs);
            builder.add_input(rhs);
            builder.add_input(lhs_scales);
            builder.add_input(lhs_zero_points);
            builder.add_input(rhs_scales);
            builder.add_input(rhs_zero_points);
            builder.add_input(output_scales);
            builder.add_input(output_zero_points);
            if let ::std::option::Option::Some(value) = &self.Tin {
                builder.set_attr_type("Tin", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tout {
                builder.set_attr_type("Tout", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.window_strides {
                builder.set_attr_int_list("window_strides", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding {
                builder.set_attr_string("padding", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.explicit_padding {
                builder.set_attr_int_list("explicit_padding", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.lhs_dilation {
                builder.set_attr_int_list("lhs_dilation", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.rhs_dilation {
                builder.set_attr_int_list("rhs_dilation", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.batch_group_count {
                builder.set_attr_int("batch_group_count", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.feature_group_count {
                builder.set_attr_int("feature_group_count", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dimension_numbers {
                builder.set_attr_string("dimension_numbers", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.lhs_quantization_axis {
                builder.set_attr_int("lhs_quantization_axis", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.lhs_quantization_min_val {
                builder.set_attr_int("lhs_quantization_min_val", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.lhs_quantization_max_val {
                builder.set_attr_int("lhs_quantization_max_val", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.rhs_quantization_axis {
                builder.set_attr_int("rhs_quantization_axis", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.rhs_quantization_min_val {
                builder.set_attr_int("rhs_quantization_min_val", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.rhs_quantization_max_val {
                builder.set_attr_int("rhs_quantization_max_val", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_quantization_axis {
                builder.set_attr_int("output_quantization_axis", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_quantization_min_val {
                builder.set_attr_int("output_quantization_min_val", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_quantization_max_val {
                builder.set_attr_int("output_quantization_max_val", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(UniformQuantizedConvolutionInst { op })
    }
}
impl UniformQuantizedConvolutionInst {
    /// Returns the 'output' Output of this 'UniformQuantizedConvolution' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'lhs' Input of this 'UniformQuantizedConvolution' operation.
    pub fn lhs(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'rhs' Input of this 'UniformQuantizedConvolution' operation.
    pub fn rhs(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'lhs_scales' Input of this 'UniformQuantizedConvolution' operation.
    pub fn lhs_scales(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'lhs_zero_points' Input of this 'UniformQuantizedConvolution' operation.
    pub fn lhs_zero_points(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'rhs_scales' Input of this 'UniformQuantizedConvolution' operation.
    pub fn rhs_scales(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
    /// Returns the 'rhs_zero_points' Input of this 'UniformQuantizedConvolution' operation.
    pub fn rhs_zero_points(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 5,
        }
    }
    /// Returns the 'output_scales' Input of this 'UniformQuantizedConvolution' operation.
    pub fn output_scales(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 6,
        }
    }
    /// Returns the 'output_zero_points' Input of this 'UniformQuantizedConvolution' operation.
    pub fn output_zero_points(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 7,
        }
    }
}
impl From<UniformQuantizedConvolutionInst> for crate::Operation {
    fn from(inst: UniformQuantizedConvolutionInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `UniformQuantizedConvolution::new().build(lhs, rhs, lhs_scales, lhs_zero_points, rhs_scales, rhs_zero_points, output_scales, output_zero_points, scope)`.
pub fn uniform_quantized_convolution<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
    O6: ::std::convert::Into<crate::Output>,
    O7: ::std::convert::Into<crate::Output>,
>(
    lhs: O0,
    rhs: O1,
    lhs_scales: O2,
    lhs_zero_points: O3,
    rhs_scales: O4,
    rhs_zero_points: O5,
    output_scales: O6,
    output_zero_points: O7,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    UniformQuantizedConvolution::new().build(
        lhs,
        rhs,
        lhs_scales,
        lhs_zero_points,
        rhs_scales,
        rhs_zero_points,
        output_scales,
        output_zero_points,
        scope,
    )
}

/// Builder for the `UniformQuantizedConvolutionHybrid` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct UniformQuantizedConvolutionHybrid {
    Tlhs: ::std::option::Option<crate::DataType>,
    Trhs: ::std::option::Option<crate::DataType>,
    Tout: ::std::option::Option<crate::DataType>,
    window_strides: ::std::option::Option<::std::vec::Vec<i64>>,
    padding: ::std::option::Option<::std::string::String>,
    explicit_padding: ::std::option::Option<::std::vec::Vec<i64>>,
    lhs_dilation: ::std::option::Option<::std::vec::Vec<i64>>,
    rhs_dilation: ::std::option::Option<::std::vec::Vec<i64>>,
    batch_group_count: ::std::option::Option<i64>,
    feature_group_count: ::std::option::Option<i64>,
    dimension_numbers: ::std::option::Option<::std::string::String>,
    rhs_quantization_axis: ::std::option::Option<i64>,
    rhs_quantization_min_val: ::std::option::Option<i64>,
    rhs_quantization_max_val: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'UniformQuantizedConvolutionHybrid' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct UniformQuantizedConvolutionHybridInst {
    /// An instance of a fully built UniformQuantizedConvolutionHybrid Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl UniformQuantizedConvolutionHybrid {
    /// Creates a new `UniformQuantizedConvolutionHybrid`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `Tlhs` attribute.
    pub fn Tlhs<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Tlhs = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Trhs` attribute.
    pub fn Trhs<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Trhs = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tout` attribute.
    pub fn Tout<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Tout = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `window_strides` attribute.
    pub fn window_strides<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.window_strides = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `padding` attribute.
    pub fn padding<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.padding = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `explicit_padding` attribute.
    pub fn explicit_padding<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.explicit_padding = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `lhs_dilation` attribute.
    pub fn lhs_dilation<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.lhs_dilation = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `rhs_dilation` attribute.
    pub fn rhs_dilation<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.rhs_dilation = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `batch_group_count` attribute.
    pub fn batch_group_count<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.batch_group_count = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `feature_group_count` attribute.
    pub fn feature_group_count<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.feature_group_count = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `dimension_numbers` attribute.
    pub fn dimension_numbers<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.dimension_numbers = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `rhs_quantization_axis` attribute.
    pub fn rhs_quantization_axis<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.rhs_quantization_axis = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `rhs_quantization_min_val` attribute.
    pub fn rhs_quantization_min_val<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.rhs_quantization_min_val = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `rhs_quantization_max_val` attribute.
    pub fn rhs_quantization_max_val<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.rhs_quantization_max_val = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `UniformQuantizedConvolutionHybrid` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
    >(
        &self,
        lhs: O0,
        rhs: O1,
        rhs_scales: O2,
        rhs_zero_points: O3,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            lhs.into(),
            rhs.into(),
            rhs_scales.into(),
            rhs_zero_points.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        lhs: crate::Output,
        rhs: crate::Output,
        rhs_scales: crate::Output,
        rhs_zero_points: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("UniformQuantizedConvolutionHybrid", |nd| {
            nd.add_input(lhs);
            nd.add_input(rhs);
            nd.add_input(rhs_scales);
            nd.add_input(rhs_zero_points);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.Tlhs {
                nd.set_attr_type("Tlhs", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Trhs {
                nd.set_attr_type("Trhs", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tout {
                nd.set_attr_type("Tout", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.window_strides {
                nd.set_attr_int_list("window_strides", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding {
                nd.set_attr_string("padding", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.explicit_padding {
                nd.set_attr_int_list("explicit_padding", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.lhs_dilation {
                nd.set_attr_int_list("lhs_dilation", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.rhs_dilation {
                nd.set_attr_int_list("rhs_dilation", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.batch_group_count {
                nd.set_attr_int("batch_group_count", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.feature_group_count {
                nd.set_attr_int("feature_group_count", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dimension_numbers {
                nd.set_attr_string("dimension_numbers", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.rhs_quantization_axis {
                nd.set_attr_int("rhs_quantization_axis", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.rhs_quantization_min_val {
                nd.set_attr_int("rhs_quantization_min_val", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.rhs_quantization_max_val {
                nd.set_attr_int("rhs_quantization_max_val", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'UniformQuantizedConvolutionHybrid' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        lhs: crate::Output,
        rhs: crate::Output,
        rhs_scales: crate::Output,
        rhs_zero_points: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<UniformQuantizedConvolutionHybridInst> {
        let op = scope.new_operation("UniformQuantizedConvolutionHybrid", |builder| {
            builder.add_input(lhs);
            builder.add_input(rhs);
            builder.add_input(rhs_scales);
            builder.add_input(rhs_zero_points);
            if let ::std::option::Option::Some(value) = &self.Tlhs {
                builder.set_attr_type("Tlhs", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Trhs {
                builder.set_attr_type("Trhs", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tout {
                builder.set_attr_type("Tout", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.window_strides {
                builder.set_attr_int_list("window_strides", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.padding {
                builder.set_attr_string("padding", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.explicit_padding {
                builder.set_attr_int_list("explicit_padding", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.lhs_dilation {
                builder.set_attr_int_list("lhs_dilation", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.rhs_dilation {
                builder.set_attr_int_list("rhs_dilation", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.batch_group_count {
                builder.set_attr_int("batch_group_count", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.feature_group_count {
                builder.set_attr_int("feature_group_count", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dimension_numbers {
                builder.set_attr_string("dimension_numbers", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.rhs_quantization_axis {
                builder.set_attr_int("rhs_quantization_axis", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.rhs_quantization_min_val {
                builder.set_attr_int("rhs_quantization_min_val", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.rhs_quantization_max_val {
                builder.set_attr_int("rhs_quantization_max_val", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(UniformQuantizedConvolutionHybridInst { op })
    }
}
impl UniformQuantizedConvolutionHybridInst {
    /// Returns the 'output' Output of this 'UniformQuantizedConvolutionHybrid' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'lhs' Input of this 'UniformQuantizedConvolutionHybrid' operation.
    pub fn lhs(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'rhs' Input of this 'UniformQuantizedConvolutionHybrid' operation.
    pub fn rhs(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'rhs_scales' Input of this 'UniformQuantizedConvolutionHybrid' operation.
    pub fn rhs_scales(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'rhs_zero_points' Input of this 'UniformQuantizedConvolutionHybrid' operation.
    pub fn rhs_zero_points(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
}
impl From<UniformQuantizedConvolutionHybridInst> for crate::Operation {
    fn from(inst: UniformQuantizedConvolutionHybridInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `UniformQuantizedConvolutionHybrid::new().build(lhs, rhs, rhs_scales, rhs_zero_points, scope)`.
pub fn uniform_quantized_convolution_hybrid<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
>(
    lhs: O0,
    rhs: O1,
    rhs_scales: O2,
    rhs_zero_points: O3,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    UniformQuantizedConvolutionHybrid::new().build(lhs, rhs, rhs_scales, rhs_zero_points, scope)
}

/// Builder for the `UniformQuantizedDot` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct UniformQuantizedDot {
    Tin: ::std::option::Option<crate::DataType>,
    Tout: ::std::option::Option<crate::DataType>,
    lhs_quantization_axis: ::std::option::Option<i64>,
    lhs_quantization_min_val: ::std::option::Option<i64>,
    lhs_quantization_max_val: ::std::option::Option<i64>,
    rhs_quantization_axis: ::std::option::Option<i64>,
    rhs_quantization_min_val: ::std::option::Option<i64>,
    rhs_quantization_max_val: ::std::option::Option<i64>,
    output_quantization_axis: ::std::option::Option<i64>,
    output_quantization_min_val: ::std::option::Option<i64>,
    output_quantization_max_val: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'UniformQuantizedDot' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct UniformQuantizedDotInst {
    /// An instance of a fully built UniformQuantizedDot Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl UniformQuantizedDot {
    /// Creates a new `UniformQuantizedDot`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `Tin` attribute.
    pub fn Tin<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Tin = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tout` attribute.
    pub fn Tout<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Tout = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `lhs_quantization_axis` attribute.
    pub fn lhs_quantization_axis<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.lhs_quantization_axis = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `lhs_quantization_min_val` attribute.
    pub fn lhs_quantization_min_val<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.lhs_quantization_min_val = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `lhs_quantization_max_val` attribute.
    pub fn lhs_quantization_max_val<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.lhs_quantization_max_val = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `rhs_quantization_axis` attribute.
    pub fn rhs_quantization_axis<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.rhs_quantization_axis = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `rhs_quantization_min_val` attribute.
    pub fn rhs_quantization_min_val<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.rhs_quantization_min_val = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `rhs_quantization_max_val` attribute.
    pub fn rhs_quantization_max_val<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.rhs_quantization_max_val = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_quantization_axis` attribute.
    pub fn output_quantization_axis<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_quantization_axis = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_quantization_min_val` attribute.
    pub fn output_quantization_min_val<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_quantization_min_val = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_quantization_max_val` attribute.
    pub fn output_quantization_max_val<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_quantization_max_val = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `UniformQuantizedDot` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
        O5: ::std::convert::Into<crate::Output>,
        O6: ::std::convert::Into<crate::Output>,
        O7: ::std::convert::Into<crate::Output>,
    >(
        &self,
        lhs: O0,
        rhs: O1,
        lhs_scales: O2,
        lhs_zero_points: O3,
        rhs_scales: O4,
        rhs_zero_points: O5,
        output_scales: O6,
        output_zero_points: O7,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            lhs.into(),
            rhs.into(),
            lhs_scales.into(),
            lhs_zero_points.into(),
            rhs_scales.into(),
            rhs_zero_points.into(),
            output_scales.into(),
            output_zero_points.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        lhs: crate::Output,
        rhs: crate::Output,
        lhs_scales: crate::Output,
        lhs_zero_points: crate::Output,
        rhs_scales: crate::Output,
        rhs_zero_points: crate::Output,
        output_scales: crate::Output,
        output_zero_points: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("UniformQuantizedDot", |nd| {
            nd.add_input(lhs);
            nd.add_input(rhs);
            nd.add_input(lhs_scales);
            nd.add_input(lhs_zero_points);
            nd.add_input(rhs_scales);
            nd.add_input(rhs_zero_points);
            nd.add_input(output_scales);
            nd.add_input(output_zero_points);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.Tin {
                nd.set_attr_type("Tin", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tout {
                nd.set_attr_type("Tout", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.lhs_quantization_axis {
                nd.set_attr_int("lhs_quantization_axis", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.lhs_quantization_min_val {
                nd.set_attr_int("lhs_quantization_min_val", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.lhs_quantization_max_val {
                nd.set_attr_int("lhs_quantization_max_val", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.rhs_quantization_axis {
                nd.set_attr_int("rhs_quantization_axis", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.rhs_quantization_min_val {
                nd.set_attr_int("rhs_quantization_min_val", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.rhs_quantization_max_val {
                nd.set_attr_int("rhs_quantization_max_val", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_quantization_axis {
                nd.set_attr_int("output_quantization_axis", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_quantization_min_val {
                nd.set_attr_int("output_quantization_min_val", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_quantization_max_val {
                nd.set_attr_int("output_quantization_max_val", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'UniformQuantizedDot' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        lhs: crate::Output,
        rhs: crate::Output,
        lhs_scales: crate::Output,
        lhs_zero_points: crate::Output,
        rhs_scales: crate::Output,
        rhs_zero_points: crate::Output,
        output_scales: crate::Output,
        output_zero_points: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<UniformQuantizedDotInst> {
        let op = scope.new_operation("UniformQuantizedDot", |builder| {
            builder.add_input(lhs);
            builder.add_input(rhs);
            builder.add_input(lhs_scales);
            builder.add_input(lhs_zero_points);
            builder.add_input(rhs_scales);
            builder.add_input(rhs_zero_points);
            builder.add_input(output_scales);
            builder.add_input(output_zero_points);
            if let ::std::option::Option::Some(value) = &self.Tin {
                builder.set_attr_type("Tin", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tout {
                builder.set_attr_type("Tout", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.lhs_quantization_axis {
                builder.set_attr_int("lhs_quantization_axis", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.lhs_quantization_min_val {
                builder.set_attr_int("lhs_quantization_min_val", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.lhs_quantization_max_val {
                builder.set_attr_int("lhs_quantization_max_val", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.rhs_quantization_axis {
                builder.set_attr_int("rhs_quantization_axis", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.rhs_quantization_min_val {
                builder.set_attr_int("rhs_quantization_min_val", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.rhs_quantization_max_val {
                builder.set_attr_int("rhs_quantization_max_val", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_quantization_axis {
                builder.set_attr_int("output_quantization_axis", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_quantization_min_val {
                builder.set_attr_int("output_quantization_min_val", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_quantization_max_val {
                builder.set_attr_int("output_quantization_max_val", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(UniformQuantizedDotInst { op })
    }
}
impl UniformQuantizedDotInst {
    /// Returns the 'output' Output of this 'UniformQuantizedDot' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'lhs' Input of this 'UniformQuantizedDot' operation.
    pub fn lhs(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'rhs' Input of this 'UniformQuantizedDot' operation.
    pub fn rhs(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'lhs_scales' Input of this 'UniformQuantizedDot' operation.
    pub fn lhs_scales(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'lhs_zero_points' Input of this 'UniformQuantizedDot' operation.
    pub fn lhs_zero_points(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'rhs_scales' Input of this 'UniformQuantizedDot' operation.
    pub fn rhs_scales(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
    /// Returns the 'rhs_zero_points' Input of this 'UniformQuantizedDot' operation.
    pub fn rhs_zero_points(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 5,
        }
    }
    /// Returns the 'output_scales' Input of this 'UniformQuantizedDot' operation.
    pub fn output_scales(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 6,
        }
    }
    /// Returns the 'output_zero_points' Input of this 'UniformQuantizedDot' operation.
    pub fn output_zero_points(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 7,
        }
    }
}
impl From<UniformQuantizedDotInst> for crate::Operation {
    fn from(inst: UniformQuantizedDotInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `UniformQuantizedDot::new().build(lhs, rhs, lhs_scales, lhs_zero_points, rhs_scales, rhs_zero_points, output_scales, output_zero_points, scope)`.
pub fn uniform_quantized_dot<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
    O5: ::std::convert::Into<crate::Output>,
    O6: ::std::convert::Into<crate::Output>,
    O7: ::std::convert::Into<crate::Output>,
>(
    lhs: O0,
    rhs: O1,
    lhs_scales: O2,
    lhs_zero_points: O3,
    rhs_scales: O4,
    rhs_zero_points: O5,
    output_scales: O6,
    output_zero_points: O7,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    UniformQuantizedDot::new().build(
        lhs,
        rhs,
        lhs_scales,
        lhs_zero_points,
        rhs_scales,
        rhs_zero_points,
        output_scales,
        output_zero_points,
        scope,
    )
}

/// Builder for the `UniformQuantizedDotHybrid` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct UniformQuantizedDotHybrid {
    Tlhs: ::std::option::Option<crate::DataType>,
    Trhs: ::std::option::Option<crate::DataType>,
    Tout: ::std::option::Option<crate::DataType>,
    rhs_quantization_axis: ::std::option::Option<i64>,
    rhs_quantization_min_val: ::std::option::Option<i64>,
    rhs_quantization_max_val: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'UniformQuantizedDotHybrid' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct UniformQuantizedDotHybridInst {
    /// An instance of a fully built UniformQuantizedDotHybrid Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl UniformQuantizedDotHybrid {
    /// Creates a new `UniformQuantizedDotHybrid`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `Tlhs` attribute.
    pub fn Tlhs<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Tlhs = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Trhs` attribute.
    pub fn Trhs<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Trhs = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tout` attribute.
    pub fn Tout<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Tout = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `rhs_quantization_axis` attribute.
    pub fn rhs_quantization_axis<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.rhs_quantization_axis = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `rhs_quantization_min_val` attribute.
    pub fn rhs_quantization_min_val<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.rhs_quantization_min_val = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `rhs_quantization_max_val` attribute.
    pub fn rhs_quantization_max_val<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.rhs_quantization_max_val = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `UniformQuantizedDotHybrid` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
    >(
        &self,
        lhs: O0,
        rhs: O1,
        rhs_scales: O2,
        rhs_zero_points: O3,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            lhs.into(),
            rhs.into(),
            rhs_scales.into(),
            rhs_zero_points.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        lhs: crate::Output,
        rhs: crate::Output,
        rhs_scales: crate::Output,
        rhs_zero_points: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("UniformQuantizedDotHybrid", |nd| {
            nd.add_input(lhs);
            nd.add_input(rhs);
            nd.add_input(rhs_scales);
            nd.add_input(rhs_zero_points);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.Tlhs {
                nd.set_attr_type("Tlhs", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Trhs {
                nd.set_attr_type("Trhs", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tout {
                nd.set_attr_type("Tout", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.rhs_quantization_axis {
                nd.set_attr_int("rhs_quantization_axis", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.rhs_quantization_min_val {
                nd.set_attr_int("rhs_quantization_min_val", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.rhs_quantization_max_val {
                nd.set_attr_int("rhs_quantization_max_val", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'UniformQuantizedDotHybrid' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        lhs: crate::Output,
        rhs: crate::Output,
        rhs_scales: crate::Output,
        rhs_zero_points: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<UniformQuantizedDotHybridInst> {
        let op = scope.new_operation("UniformQuantizedDotHybrid", |builder| {
            builder.add_input(lhs);
            builder.add_input(rhs);
            builder.add_input(rhs_scales);
            builder.add_input(rhs_zero_points);
            if let ::std::option::Option::Some(value) = &self.Tlhs {
                builder.set_attr_type("Tlhs", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Trhs {
                builder.set_attr_type("Trhs", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tout {
                builder.set_attr_type("Tout", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.rhs_quantization_axis {
                builder.set_attr_int("rhs_quantization_axis", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.rhs_quantization_min_val {
                builder.set_attr_int("rhs_quantization_min_val", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.rhs_quantization_max_val {
                builder.set_attr_int("rhs_quantization_max_val", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(UniformQuantizedDotHybridInst { op })
    }
}
impl UniformQuantizedDotHybridInst {
    /// Returns the 'output' Output of this 'UniformQuantizedDotHybrid' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'lhs' Input of this 'UniformQuantizedDotHybrid' operation.
    pub fn lhs(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'rhs' Input of this 'UniformQuantizedDotHybrid' operation.
    pub fn rhs(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'rhs_scales' Input of this 'UniformQuantizedDotHybrid' operation.
    pub fn rhs_scales(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'rhs_zero_points' Input of this 'UniformQuantizedDotHybrid' operation.
    pub fn rhs_zero_points(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
}
impl From<UniformQuantizedDotHybridInst> for crate::Operation {
    fn from(inst: UniformQuantizedDotHybridInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `UniformQuantizedDotHybrid::new().build(lhs, rhs, rhs_scales, rhs_zero_points, scope)`.
pub fn uniform_quantized_dot_hybrid<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
>(
    lhs: O0,
    rhs: O1,
    rhs_scales: O2,
    rhs_zero_points: O3,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    UniformQuantizedDotHybrid::new().build(lhs, rhs, rhs_scales, rhs_zero_points, scope)
}

/// Builder for the `UniformRequantize` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct UniformRequantize {
    Tin: ::std::option::Option<crate::DataType>,
    Tout: ::std::option::Option<crate::DataType>,
    input_quantization_axis: ::std::option::Option<i64>,
    input_quantization_min_val: ::std::option::Option<i64>,
    input_quantization_max_val: ::std::option::Option<i64>,
    output_quantization_axis: ::std::option::Option<i64>,
    output_quantization_min_val: ::std::option::Option<i64>,
    output_quantization_max_val: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'UniformRequantize' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct UniformRequantizeInst {
    /// An instance of a fully built UniformRequantize Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl UniformRequantize {
    /// Creates a new `UniformRequantize`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `Tin` attribute.
    pub fn Tin<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Tin = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tout` attribute.
    pub fn Tout<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Tout = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `input_quantization_axis` attribute.
    pub fn input_quantization_axis<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.input_quantization_axis = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `input_quantization_min_val` attribute.
    pub fn input_quantization_min_val<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.input_quantization_min_val = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `input_quantization_max_val` attribute.
    pub fn input_quantization_max_val<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.input_quantization_max_val = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_quantization_axis` attribute.
    pub fn output_quantization_axis<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_quantization_axis = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_quantization_min_val` attribute.
    pub fn output_quantization_min_val<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_quantization_min_val = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_quantization_max_val` attribute.
    pub fn output_quantization_max_val<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_quantization_max_val = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `UniformRequantize` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input: O0,
        input_scales: O1,
        input_zero_points: O2,
        output_scales: O3,
        output_zero_points: O4,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            input.into(),
            input_scales.into(),
            input_zero_points.into(),
            output_scales.into(),
            output_zero_points.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        input: crate::Output,
        input_scales: crate::Output,
        input_zero_points: crate::Output,
        output_scales: crate::Output,
        output_zero_points: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("UniformRequantize", |nd| {
            nd.add_input(input);
            nd.add_input(input_scales);
            nd.add_input(input_zero_points);
            nd.add_input(output_scales);
            nd.add_input(output_zero_points);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.Tin {
                nd.set_attr_type("Tin", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tout {
                nd.set_attr_type("Tout", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.input_quantization_axis {
                nd.set_attr_int("input_quantization_axis", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.input_quantization_min_val {
                nd.set_attr_int("input_quantization_min_val", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.input_quantization_max_val {
                nd.set_attr_int("input_quantization_max_val", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_quantization_axis {
                nd.set_attr_int("output_quantization_axis", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_quantization_min_val {
                nd.set_attr_int("output_quantization_min_val", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_quantization_max_val {
                nd.set_attr_int("output_quantization_max_val", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'UniformRequantize' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        input_scales: crate::Output,
        input_zero_points: crate::Output,
        output_scales: crate::Output,
        output_zero_points: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<UniformRequantizeInst> {
        let op = scope.new_operation("UniformRequantize", |builder| {
            builder.add_input(input);
            builder.add_input(input_scales);
            builder.add_input(input_zero_points);
            builder.add_input(output_scales);
            builder.add_input(output_zero_points);
            if let ::std::option::Option::Some(value) = &self.Tin {
                builder.set_attr_type("Tin", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tout {
                builder.set_attr_type("Tout", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.input_quantization_axis {
                builder.set_attr_int("input_quantization_axis", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.input_quantization_min_val {
                builder.set_attr_int("input_quantization_min_val", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.input_quantization_max_val {
                builder.set_attr_int("input_quantization_max_val", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_quantization_axis {
                builder.set_attr_int("output_quantization_axis", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_quantization_min_val {
                builder.set_attr_int("output_quantization_min_val", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_quantization_max_val {
                builder.set_attr_int("output_quantization_max_val", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(UniformRequantizeInst { op })
    }
}
impl UniformRequantizeInst {
    /// Returns the 'output' Output of this 'UniformRequantize' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'UniformRequantize' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'input_scales' Input of this 'UniformRequantize' operation.
    pub fn input_scales(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'input_zero_points' Input of this 'UniformRequantize' operation.
    pub fn input_zero_points(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'output_scales' Input of this 'UniformRequantize' operation.
    pub fn output_scales(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'output_zero_points' Input of this 'UniformRequantize' operation.
    pub fn output_zero_points(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
}
impl From<UniformRequantizeInst> for crate::Operation {
    fn from(inst: UniformRequantizeInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `UniformRequantize::new().build(input, input_scales, input_zero_points, output_scales, output_zero_points, scope)`.
pub fn uniform_requantize<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
>(
    input: O0,
    input_scales: O1,
    input_zero_points: O2,
    output_scales: O3,
    output_zero_points: O4,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    UniformRequantize::new().build(
        input,
        input_scales,
        input_zero_points,
        output_scales,
        output_zero_points,
        scope,
    )
}

/// Builder for the `Unique` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Unique {
    T: ::std::option::Option<crate::DataType>,
    out_idx: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Unique' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct UniqueInst {
    /// An instance of a fully built Unique Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Unique {
    /// Creates a new `Unique`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `out_idx` attribute.
    pub fn out_idx<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.out_idx = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Unique` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        x: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Unique", |nd| {
            nd.add_input(x);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.out_idx {
                nd.set_attr_type("out_idx", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Unique' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<UniqueInst> {
        let op = scope.new_operation("Unique", |builder| {
            builder.add_input(x);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.out_idx {
                builder.set_attr_type("out_idx", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(UniqueInst { op })
    }
}
impl UniqueInst {
    /// Returns the 'y' Output of this 'Unique' operation.
    pub fn y(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'idx' Output of this 'Unique' operation.
    pub fn idx(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'x' Input of this 'Unique' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<UniqueInst> for crate::Operation {
    fn from(inst: UniqueInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Unique::new().build(x, scope)`.
pub fn unique<O0: ::std::convert::Into<crate::Output>>(
    x: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Unique::new().build(x, scope)
}

/// Builder for the `UniqueDataset` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct UniqueDataset {
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    metadata: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'UniqueDataset' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct UniqueDatasetInst {
    /// An instance of a fully built UniqueDataset Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl UniqueDataset {
    /// Creates a new `UniqueDataset`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `metadata` attribute.
    pub fn metadata<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.metadata = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `UniqueDataset` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input_dataset: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input_dataset.into(), scope)
    }
    fn build_impl(
        &self,
        input_dataset: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("UniqueDataset", |nd| {
            nd.add_input(input_dataset);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.metadata {
                nd.set_attr_string("metadata", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'UniqueDataset' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_dataset: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<UniqueDatasetInst> {
        let op = scope.new_operation("UniqueDataset", |builder| {
            builder.add_input(input_dataset);
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.metadata {
                builder.set_attr_string("metadata", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(UniqueDatasetInst { op })
    }
}
impl UniqueDatasetInst {
    /// Returns the 'handle' Output of this 'UniqueDataset' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_dataset' Input of this 'UniqueDataset' operation.
    pub fn input_dataset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<UniqueDatasetInst> for crate::Operation {
    fn from(inst: UniqueDatasetInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `UniqueDataset::new().build(input_dataset, scope)`.
pub fn unique_dataset<O0: ::std::convert::Into<crate::Output>>(
    input_dataset: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    UniqueDataset::new().build(input_dataset, scope)
}

/// Builder for the `UniqueV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct UniqueV2 {
    T: ::std::option::Option<crate::DataType>,
    Taxis: ::std::option::Option<crate::DataType>,
    out_idx: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'UniqueV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct UniqueV2Inst {
    /// An instance of a fully built UniqueV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl UniqueV2 {
    /// Creates a new `UniqueV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Taxis` attribute.
    pub fn Taxis<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Taxis = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `out_idx` attribute.
    pub fn out_idx<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.out_idx = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `UniqueV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        x: O0,
        axis: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), axis.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        axis: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("UniqueV2", |nd| {
            nd.add_input(x);
            nd.add_input(axis);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Taxis {
                nd.set_attr_type("Taxis", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.out_idx {
                nd.set_attr_type("out_idx", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'UniqueV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        axis: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<UniqueV2Inst> {
        let op = scope.new_operation("UniqueV2", |builder| {
            builder.add_input(x);
            builder.add_input(axis);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Taxis {
                builder.set_attr_type("Taxis", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.out_idx {
                builder.set_attr_type("out_idx", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(UniqueV2Inst { op })
    }
}
impl UniqueV2Inst {
    /// Returns the 'y' Output of this 'UniqueV2' operation.
    pub fn y(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'idx' Output of this 'UniqueV2' operation.
    pub fn idx(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'x' Input of this 'UniqueV2' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'axis' Input of this 'UniqueV2' operation.
    pub fn axis(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<UniqueV2Inst> for crate::Operation {
    fn from(inst: UniqueV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `UniqueV2::new().build(x, axis, scope)`.
pub fn unique_v2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    x: O0,
    axis: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    UniqueV2::new().build(x, axis, scope)
}

/// Builder for the `UniqueWithCounts` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct UniqueWithCounts {
    T: ::std::option::Option<crate::DataType>,
    out_idx: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'UniqueWithCounts' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct UniqueWithCountsInst {
    /// An instance of a fully built UniqueWithCounts Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl UniqueWithCounts {
    /// Creates a new `UniqueWithCounts`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `out_idx` attribute.
    pub fn out_idx<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.out_idx = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `UniqueWithCounts` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        x: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("UniqueWithCounts", |nd| {
            nd.add_input(x);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.out_idx {
                nd.set_attr_type("out_idx", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'UniqueWithCounts' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<UniqueWithCountsInst> {
        let op = scope.new_operation("UniqueWithCounts", |builder| {
            builder.add_input(x);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.out_idx {
                builder.set_attr_type("out_idx", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(UniqueWithCountsInst { op })
    }
}
impl UniqueWithCountsInst {
    /// Returns the 'y' Output of this 'UniqueWithCounts' operation.
    pub fn y(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'idx' Output of this 'UniqueWithCounts' operation.
    pub fn idx(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'count' Output of this 'UniqueWithCounts' operation.
    pub fn count(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns the 'x' Input of this 'UniqueWithCounts' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<UniqueWithCountsInst> for crate::Operation {
    fn from(inst: UniqueWithCountsInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `UniqueWithCounts::new().build(x, scope)`.
pub fn unique_with_counts<O0: ::std::convert::Into<crate::Output>>(
    x: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    UniqueWithCounts::new().build(x, scope)
}

/// Builder for the `UniqueWithCountsV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct UniqueWithCountsV2 {
    T: ::std::option::Option<crate::DataType>,
    Taxis: ::std::option::Option<crate::DataType>,
    out_idx: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'UniqueWithCountsV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct UniqueWithCountsV2Inst {
    /// An instance of a fully built UniqueWithCountsV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl UniqueWithCountsV2 {
    /// Creates a new `UniqueWithCountsV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Taxis` attribute.
    pub fn Taxis<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Taxis = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `out_idx` attribute.
    pub fn out_idx<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.out_idx = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `UniqueWithCountsV2` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        x: O0,
        axis: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), axis.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        axis: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("UniqueWithCountsV2", |nd| {
            nd.add_input(x);
            nd.add_input(axis);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Taxis {
                nd.set_attr_type("Taxis", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.out_idx {
                nd.set_attr_type("out_idx", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'UniqueWithCountsV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        axis: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<UniqueWithCountsV2Inst> {
        let op = scope.new_operation("UniqueWithCountsV2", |builder| {
            builder.add_input(x);
            builder.add_input(axis);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Taxis {
                builder.set_attr_type("Taxis", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.out_idx {
                builder.set_attr_type("out_idx", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(UniqueWithCountsV2Inst { op })
    }
}
impl UniqueWithCountsV2Inst {
    /// Returns the 'y' Output of this 'UniqueWithCountsV2' operation.
    pub fn y(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'idx' Output of this 'UniqueWithCountsV2' operation.
    pub fn idx(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 1,
        }
    }
    /// Returns the 'count' Output of this 'UniqueWithCountsV2' operation.
    pub fn count(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 2,
        }
    }
    /// Returns the 'x' Input of this 'UniqueWithCountsV2' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'axis' Input of this 'UniqueWithCountsV2' operation.
    pub fn axis(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<UniqueWithCountsV2Inst> for crate::Operation {
    fn from(inst: UniqueWithCountsV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `UniqueWithCountsV2::new().build(x, axis, scope)`.
pub fn unique_with_counts_v2<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    x: O0,
    axis: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    UniqueWithCountsV2::new().build(x, axis, scope)
}

/// Builder for the `Unpack` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Unpack {
    num: ::std::option::Option<i64>,
    T: ::std::option::Option<crate::DataType>,
    axis: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Unpack' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct UnpackInst {
    /// An instance of a fully built Unpack Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Unpack {
    /// Creates a new `Unpack`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `num` attribute.
    pub fn num<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.num = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `axis` attribute.
    pub fn axis<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.axis = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Unpack` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        value: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(value.into(), scope)
    }
    fn build_impl(
        &self,
        value: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Unpack", |nd| {
            nd.add_input(value);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.num {
                nd.set_attr_int("num", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.axis {
                nd.set_attr_int("axis", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Unpack' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        value: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<UnpackInst> {
        let op = scope.new_operation("Unpack", |builder| {
            builder.add_input(value);
            if let ::std::option::Option::Some(value) = &self.num {
                builder.set_attr_int("num", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.axis {
                builder.set_attr_int("axis", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(UnpackInst { op })
    }
}
impl UnpackInst {
    /// Returns a Vector of output for 'output' Output of this Unpack operation.
    pub fn output(&self) -> crate::Result<Vec<crate::Output>> {
        let mut Outputs = vec![];
        for i in 0..self.op.get_attr_int("num")? as i32 {
            Outputs.push(crate::Output {
                operation: self.op.clone(),
                index: i,
            });
        }
        Ok(Outputs)
    }
    /// Returns the 'value' Input of this 'Unpack' operation.
    pub fn value(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<UnpackInst> for crate::Operation {
    fn from(inst: UnpackInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Unpack::new().build(value, scope)`.
pub fn unpack<O0: ::std::convert::Into<crate::Output>>(
    value: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Unpack::new().build(value, scope)
}

/// Builder for the `UnravelIndex` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct UnravelIndex {
    Tidx: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'UnravelIndex' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct UnravelIndexInst {
    /// An instance of a fully built UnravelIndex Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl UnravelIndex {
    /// Creates a new `UnravelIndex`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `Tidx` attribute.
    pub fn Tidx<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.Tidx = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `UnravelIndex` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        indices: O0,
        dims: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(indices.into(), dims.into(), scope)
    }
    fn build_impl(
        &self,
        indices: crate::Output,
        dims: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("UnravelIndex", |nd| {
            nd.add_input(indices);
            nd.add_input(dims);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.Tidx {
                nd.set_attr_type("Tidx", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'UnravelIndex' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        indices: crate::Output,
        dims: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<UnravelIndexInst> {
        let op = scope.new_operation("UnravelIndex", |builder| {
            builder.add_input(indices);
            builder.add_input(dims);
            if let ::std::option::Option::Some(value) = &self.Tidx {
                builder.set_attr_type("Tidx", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(UnravelIndexInst { op })
    }
}
impl UnravelIndexInst {
    /// Returns the 'output' Output of this 'UnravelIndex' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'indices' Input of this 'UnravelIndex' operation.
    pub fn indices(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'dims' Input of this 'UnravelIndex' operation.
    pub fn dims(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<UnravelIndexInst> for crate::Operation {
    fn from(inst: UnravelIndexInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `UnravelIndex::new().build(indices, dims, scope)`.
pub fn unravel_index<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    indices: O0,
    dims: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    UnravelIndex::new().build(indices, dims, scope)
}

/// Builder for the `UnsortedSegmentJoin` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct UnsortedSegmentJoin {
    separator: ::std::option::Option<::std::string::String>,
    Tindices: ::std::option::Option<crate::DataType>,
    Tnumsegments: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'UnsortedSegmentJoin' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct UnsortedSegmentJoinInst {
    /// An instance of a fully built UnsortedSegmentJoin Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl UnsortedSegmentJoin {
    /// Creates a new `UnsortedSegmentJoin`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `separator` attribute.
    pub fn separator<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.separator = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tindices` attribute.
    pub fn Tindices<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tindices = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tnumsegments` attribute.
    pub fn Tnumsegments<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tnumsegments = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `UnsortedSegmentJoin` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        inputs: O0,
        segment_ids: O1,
        num_segments: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            inputs.into(),
            segment_ids.into(),
            num_segments.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        inputs: crate::Output,
        segment_ids: crate::Output,
        num_segments: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("UnsortedSegmentJoin", |nd| {
            nd.add_input(inputs);
            nd.add_input(segment_ids);
            nd.add_input(num_segments);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.separator {
                nd.set_attr_string("separator", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                nd.set_attr_type("Tindices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tnumsegments {
                nd.set_attr_type("Tnumsegments", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'UnsortedSegmentJoin' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        inputs: crate::Output,
        segment_ids: crate::Output,
        num_segments: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<UnsortedSegmentJoinInst> {
        let op = scope.new_operation("UnsortedSegmentJoin", |builder| {
            builder.add_input(inputs);
            builder.add_input(segment_ids);
            builder.add_input(num_segments);
            if let ::std::option::Option::Some(value) = &self.separator {
                builder.set_attr_string("separator", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                builder.set_attr_type("Tindices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tnumsegments {
                builder.set_attr_type("Tnumsegments", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(UnsortedSegmentJoinInst { op })
    }
}
impl UnsortedSegmentJoinInst {
    /// Returns the 'output' Output of this 'UnsortedSegmentJoin' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'inputs' Input of this 'UnsortedSegmentJoin' operation.
    pub fn inputs(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'segment_ids' Input of this 'UnsortedSegmentJoin' operation.
    pub fn segment_ids(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'num_segments' Input of this 'UnsortedSegmentJoin' operation.
    pub fn num_segments(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<UnsortedSegmentJoinInst> for crate::Operation {
    fn from(inst: UnsortedSegmentJoinInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `UnsortedSegmentJoin::new().build(inputs, segment_ids, num_segments, scope)`.
pub fn unsorted_segment_join<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    inputs: O0,
    segment_ids: O1,
    num_segments: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    UnsortedSegmentJoin::new().build(inputs, segment_ids, num_segments, scope)
}

/// Builder for the `UnsortedSegmentMax` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct UnsortedSegmentMax {
    T: ::std::option::Option<crate::DataType>,
    Tindices: ::std::option::Option<crate::DataType>,
    Tnumsegments: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'UnsortedSegmentMax' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct UnsortedSegmentMaxInst {
    /// An instance of a fully built UnsortedSegmentMax Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl UnsortedSegmentMax {
    /// Creates a new `UnsortedSegmentMax`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tindices` attribute.
    pub fn Tindices<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tindices = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tnumsegments` attribute.
    pub fn Tnumsegments<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tnumsegments = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `UnsortedSegmentMax` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        data: O0,
        segment_ids: O1,
        num_segments: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(data.into(), segment_ids.into(), num_segments.into(), scope)
    }
    fn build_impl(
        &self,
        data: crate::Output,
        segment_ids: crate::Output,
        num_segments: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("UnsortedSegmentMax", |nd| {
            nd.add_input(data);
            nd.add_input(segment_ids);
            nd.add_input(num_segments);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                nd.set_attr_type("Tindices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tnumsegments {
                nd.set_attr_type("Tnumsegments", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'UnsortedSegmentMax' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        data: crate::Output,
        segment_ids: crate::Output,
        num_segments: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<UnsortedSegmentMaxInst> {
        let op = scope.new_operation("UnsortedSegmentMax", |builder| {
            builder.add_input(data);
            builder.add_input(segment_ids);
            builder.add_input(num_segments);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                builder.set_attr_type("Tindices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tnumsegments {
                builder.set_attr_type("Tnumsegments", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(UnsortedSegmentMaxInst { op })
    }
}
impl UnsortedSegmentMaxInst {
    /// Returns the 'output' Output of this 'UnsortedSegmentMax' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'data' Input of this 'UnsortedSegmentMax' operation.
    pub fn data(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'segment_ids' Input of this 'UnsortedSegmentMax' operation.
    pub fn segment_ids(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'num_segments' Input of this 'UnsortedSegmentMax' operation.
    pub fn num_segments(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<UnsortedSegmentMaxInst> for crate::Operation {
    fn from(inst: UnsortedSegmentMaxInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `UnsortedSegmentMax::new().build(data, segment_ids, num_segments, scope)`.
pub fn unsorted_segment_max<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    data: O0,
    segment_ids: O1,
    num_segments: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    UnsortedSegmentMax::new().build(data, segment_ids, num_segments, scope)
}

/// Builder for the `UnsortedSegmentMin` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct UnsortedSegmentMin {
    T: ::std::option::Option<crate::DataType>,
    Tindices: ::std::option::Option<crate::DataType>,
    Tnumsegments: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'UnsortedSegmentMin' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct UnsortedSegmentMinInst {
    /// An instance of a fully built UnsortedSegmentMin Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl UnsortedSegmentMin {
    /// Creates a new `UnsortedSegmentMin`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tindices` attribute.
    pub fn Tindices<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tindices = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tnumsegments` attribute.
    pub fn Tnumsegments<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tnumsegments = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `UnsortedSegmentMin` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        data: O0,
        segment_ids: O1,
        num_segments: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(data.into(), segment_ids.into(), num_segments.into(), scope)
    }
    fn build_impl(
        &self,
        data: crate::Output,
        segment_ids: crate::Output,
        num_segments: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("UnsortedSegmentMin", |nd| {
            nd.add_input(data);
            nd.add_input(segment_ids);
            nd.add_input(num_segments);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                nd.set_attr_type("Tindices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tnumsegments {
                nd.set_attr_type("Tnumsegments", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'UnsortedSegmentMin' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        data: crate::Output,
        segment_ids: crate::Output,
        num_segments: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<UnsortedSegmentMinInst> {
        let op = scope.new_operation("UnsortedSegmentMin", |builder| {
            builder.add_input(data);
            builder.add_input(segment_ids);
            builder.add_input(num_segments);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                builder.set_attr_type("Tindices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tnumsegments {
                builder.set_attr_type("Tnumsegments", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(UnsortedSegmentMinInst { op })
    }
}
impl UnsortedSegmentMinInst {
    /// Returns the 'output' Output of this 'UnsortedSegmentMin' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'data' Input of this 'UnsortedSegmentMin' operation.
    pub fn data(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'segment_ids' Input of this 'UnsortedSegmentMin' operation.
    pub fn segment_ids(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'num_segments' Input of this 'UnsortedSegmentMin' operation.
    pub fn num_segments(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<UnsortedSegmentMinInst> for crate::Operation {
    fn from(inst: UnsortedSegmentMinInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `UnsortedSegmentMin::new().build(data, segment_ids, num_segments, scope)`.
pub fn unsorted_segment_min<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    data: O0,
    segment_ids: O1,
    num_segments: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    UnsortedSegmentMin::new().build(data, segment_ids, num_segments, scope)
}

/// Builder for the `UnsortedSegmentProd` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct UnsortedSegmentProd {
    T: ::std::option::Option<crate::DataType>,
    Tindices: ::std::option::Option<crate::DataType>,
    Tnumsegments: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'UnsortedSegmentProd' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct UnsortedSegmentProdInst {
    /// An instance of a fully built UnsortedSegmentProd Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl UnsortedSegmentProd {
    /// Creates a new `UnsortedSegmentProd`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tindices` attribute.
    pub fn Tindices<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tindices = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tnumsegments` attribute.
    pub fn Tnumsegments<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tnumsegments = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `UnsortedSegmentProd` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        data: O0,
        segment_ids: O1,
        num_segments: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(data.into(), segment_ids.into(), num_segments.into(), scope)
    }
    fn build_impl(
        &self,
        data: crate::Output,
        segment_ids: crate::Output,
        num_segments: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("UnsortedSegmentProd", |nd| {
            nd.add_input(data);
            nd.add_input(segment_ids);
            nd.add_input(num_segments);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                nd.set_attr_type("Tindices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tnumsegments {
                nd.set_attr_type("Tnumsegments", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'UnsortedSegmentProd' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        data: crate::Output,
        segment_ids: crate::Output,
        num_segments: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<UnsortedSegmentProdInst> {
        let op = scope.new_operation("UnsortedSegmentProd", |builder| {
            builder.add_input(data);
            builder.add_input(segment_ids);
            builder.add_input(num_segments);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                builder.set_attr_type("Tindices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tnumsegments {
                builder.set_attr_type("Tnumsegments", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(UnsortedSegmentProdInst { op })
    }
}
impl UnsortedSegmentProdInst {
    /// Returns the 'output' Output of this 'UnsortedSegmentProd' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'data' Input of this 'UnsortedSegmentProd' operation.
    pub fn data(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'segment_ids' Input of this 'UnsortedSegmentProd' operation.
    pub fn segment_ids(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'num_segments' Input of this 'UnsortedSegmentProd' operation.
    pub fn num_segments(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<UnsortedSegmentProdInst> for crate::Operation {
    fn from(inst: UnsortedSegmentProdInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `UnsortedSegmentProd::new().build(data, segment_ids, num_segments, scope)`.
pub fn unsorted_segment_prod<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    data: O0,
    segment_ids: O1,
    num_segments: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    UnsortedSegmentProd::new().build(data, segment_ids, num_segments, scope)
}

/// Builder for the `UnsortedSegmentSum` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct UnsortedSegmentSum {
    T: ::std::option::Option<crate::DataType>,
    Tindices: ::std::option::Option<crate::DataType>,
    Tnumsegments: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'UnsortedSegmentSum' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct UnsortedSegmentSumInst {
    /// An instance of a fully built UnsortedSegmentSum Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl UnsortedSegmentSum {
    /// Creates a new `UnsortedSegmentSum`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tindices` attribute.
    pub fn Tindices<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tindices = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tnumsegments` attribute.
    pub fn Tnumsegments<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tnumsegments = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `UnsortedSegmentSum` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        data: O0,
        segment_ids: O1,
        num_segments: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(data.into(), segment_ids.into(), num_segments.into(), scope)
    }
    fn build_impl(
        &self,
        data: crate::Output,
        segment_ids: crate::Output,
        num_segments: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("UnsortedSegmentSum", |nd| {
            nd.add_input(data);
            nd.add_input(segment_ids);
            nd.add_input(num_segments);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                nd.set_attr_type("Tindices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tnumsegments {
                nd.set_attr_type("Tnumsegments", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'UnsortedSegmentSum' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        data: crate::Output,
        segment_ids: crate::Output,
        num_segments: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<UnsortedSegmentSumInst> {
        let op = scope.new_operation("UnsortedSegmentSum", |builder| {
            builder.add_input(data);
            builder.add_input(segment_ids);
            builder.add_input(num_segments);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tindices {
                builder.set_attr_type("Tindices", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tnumsegments {
                builder.set_attr_type("Tnumsegments", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(UnsortedSegmentSumInst { op })
    }
}
impl UnsortedSegmentSumInst {
    /// Returns the 'output' Output of this 'UnsortedSegmentSum' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'data' Input of this 'UnsortedSegmentSum' operation.
    pub fn data(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'segment_ids' Input of this 'UnsortedSegmentSum' operation.
    pub fn segment_ids(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'num_segments' Input of this 'UnsortedSegmentSum' operation.
    pub fn num_segments(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<UnsortedSegmentSumInst> for crate::Operation {
    fn from(inst: UnsortedSegmentSumInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `UnsortedSegmentSum::new().build(data, segment_ids, num_segments, scope)`.
pub fn unsorted_segment_sum<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    data: O0,
    segment_ids: O1,
    num_segments: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    UnsortedSegmentSum::new().build(data, segment_ids, num_segments, scope)
}

/// Builder for the `Unstage` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Unstage {
    capacity: ::std::option::Option<i64>,
    memory_limit: ::std::option::Option<i64>,
    dtypes: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    container: ::std::option::Option<::std::string::String>,
    shared_name: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Unstage' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct UnstageInst {
    /// An instance of a fully built Unstage Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Unstage {
    /// Creates a new `Unstage`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `capacity` attribute.
    pub fn capacity<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.capacity = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `memory_limit` attribute.
    pub fn memory_limit<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.memory_limit = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `dtypes` attribute.
    pub fn dtypes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.dtypes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `container` attribute.
    pub fn container<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.container = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shared_name` attribute.
    pub fn shared_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.shared_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Unstage` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("Unstage", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.capacity {
                nd.set_attr_int("capacity", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.memory_limit {
                nd.set_attr_int("memory_limit", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dtypes {
                nd.set_attr_type_list("dtypes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.container {
                nd.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                nd.set_attr_string("shared_name", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Unstage' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(&self, scope: &mut crate::Scope) -> crate::Result<UnstageInst> {
        let op = scope.new_operation("Unstage", |builder| {
            if let ::std::option::Option::Some(value) = &self.capacity {
                builder.set_attr_int("capacity", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.memory_limit {
                builder.set_attr_int("memory_limit", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dtypes {
                builder.set_attr_type_list("dtypes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.container {
                builder.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                builder.set_attr_string("shared_name", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(UnstageInst { op })
    }
}
impl UnstageInst {
    /// Returns the 'values' Output of this 'Unstage' operation.
    pub fn values(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
}
impl From<UnstageInst> for crate::Operation {
    fn from(inst: UnstageInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Unstage::new().build(scope)`.
pub fn unstage(scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
    Unstage::new().build(scope)
}

/// Builder for the `UnwrapDatasetVariant` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct UnwrapDatasetVariant {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'UnwrapDatasetVariant' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct UnwrapDatasetVariantInst {
    /// An instance of a fully built UnwrapDatasetVariant Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl UnwrapDatasetVariant {
    /// Creates a new `UnwrapDatasetVariant`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `UnwrapDatasetVariant` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input_handle: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input_handle.into(), scope)
    }
    fn build_impl(
        &self,
        input_handle: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("UnwrapDatasetVariant", |nd| {
            nd.add_input(input_handle);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'UnwrapDatasetVariant' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_handle: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<UnwrapDatasetVariantInst> {
        let op = scope.new_operation("UnwrapDatasetVariant", |builder| {
            builder.add_input(input_handle);
            ::std::result::Result::Ok(())
        })?;
        Ok(UnwrapDatasetVariantInst { op })
    }
}
impl UnwrapDatasetVariantInst {
    /// Returns the 'output_handle' Output of this 'UnwrapDatasetVariant' operation.
    pub fn output_handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_handle' Input of this 'UnwrapDatasetVariant' operation.
    pub fn input_handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<UnwrapDatasetVariantInst> for crate::Operation {
    fn from(inst: UnwrapDatasetVariantInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `UnwrapDatasetVariant::new().build(input_handle, scope)`.
pub fn unwrap_dataset_variant<O0: ::std::convert::Into<crate::Output>>(
    input_handle: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    UnwrapDatasetVariant::new().build(input_handle, scope)
}

/// Builder for the `UpperBound` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct UpperBound {
    T: ::std::option::Option<crate::DataType>,
    out_type: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'UpperBound' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct UpperBoundInst {
    /// An instance of a fully built UpperBound Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl UpperBound {
    /// Creates a new `UpperBound`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `out_type` attribute.
    pub fn out_type<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.out_type = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `UpperBound` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        sorted_inputs: O0,
        values: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(sorted_inputs.into(), values.into(), scope)
    }
    fn build_impl(
        &self,
        sorted_inputs: crate::Output,
        values: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("UpperBound", |nd| {
            nd.add_input(sorted_inputs);
            nd.add_input(values);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.out_type {
                nd.set_attr_type("out_type", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'UpperBound' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        sorted_inputs: crate::Output,
        values: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<UpperBoundInst> {
        let op = scope.new_operation("UpperBound", |builder| {
            builder.add_input(sorted_inputs);
            builder.add_input(values);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.out_type {
                builder.set_attr_type("out_type", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(UpperBoundInst { op })
    }
}
impl UpperBoundInst {
    /// Returns the 'output' Output of this 'UpperBound' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'sorted_inputs' Input of this 'UpperBound' operation.
    pub fn sorted_inputs(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'values' Input of this 'UpperBound' operation.
    pub fn values(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<UpperBoundInst> for crate::Operation {
    fn from(inst: UpperBoundInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `UpperBound::new().build(sorted_inputs, values, scope)`.
pub fn upper_bound<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    sorted_inputs: O0,
    values: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    UpperBound::new().build(sorted_inputs, values, scope)
}

/// Builder for the `VarHandleOp` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct VarHandleOp {
    container: ::std::option::Option<::std::string::String>,
    shared_name: ::std::option::Option<::std::string::String>,
    dtype: ::std::option::Option<crate::DataType>,
    shape: ::std::option::Option<crate::Shape>,
    allowed_devices: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'VarHandleOp' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct VarHandleOpInst {
    /// An instance of a fully built VarHandleOp Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl VarHandleOp {
    /// Creates a new `VarHandleOp`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `container` attribute.
    pub fn container<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.container = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shared_name` attribute.
    pub fn shared_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.shared_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `dtype` attribute.
    pub fn dtype<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shape` attribute.
    pub fn shape<ArgType: ::std::convert::Into<crate::Shape>>(mut self, value: ArgType) -> Self {
        self.shape = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `allowed_devices` attribute.
    pub fn allowed_devices<
        ArgType: ::std::convert::Into<::std::vec::Vec<::std::string::String>>,
    >(
        mut self,
        value: ArgType,
    ) -> Self {
        self.allowed_devices = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `VarHandleOp` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("VarHandleOp", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.container {
                nd.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                nd.set_attr_string("shared_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                nd.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shape {
                nd.set_attr_shape("shape", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.allowed_devices {
                nd.set_attr_string_list("allowed_devices", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'VarHandleOp' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(&self, scope: &mut crate::Scope) -> crate::Result<VarHandleOpInst> {
        let op = scope.new_operation("VarHandleOp", |builder| {
            if let ::std::option::Option::Some(value) = &self.container {
                builder.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                builder.set_attr_string("shared_name", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                builder.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shape {
                builder.set_attr_shape("shape", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.allowed_devices {
                builder.set_attr_string_list("allowed_devices", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(VarHandleOpInst { op })
    }
}
impl VarHandleOpInst {
    /// Returns the 'resource' Output of this 'VarHandleOp' operation.
    pub fn resource(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
}
impl From<VarHandleOpInst> for crate::Operation {
    fn from(inst: VarHandleOpInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `VarHandleOp::new().build(scope)`.
pub fn var_handle_op(scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
    VarHandleOp::new().build(scope)
}

/// Builder for the `VarIsInitializedOp` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct VarIsInitializedOp {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'VarIsInitializedOp' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct VarIsInitializedOpInst {
    /// An instance of a fully built VarIsInitializedOp Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl VarIsInitializedOp {
    /// Creates a new `VarIsInitializedOp`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `VarIsInitializedOp` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        resource: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(resource.into(), scope)
    }
    fn build_impl(
        &self,
        resource: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("VarIsInitializedOp", |nd| {
            nd.add_input(resource);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'VarIsInitializedOp' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        resource: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<VarIsInitializedOpInst> {
        let op = scope.new_operation("VarIsInitializedOp", |builder| {
            builder.add_input(resource);
            ::std::result::Result::Ok(())
        })?;
        Ok(VarIsInitializedOpInst { op })
    }
}
impl VarIsInitializedOpInst {
    /// Returns the 'is_initialized' Output of this 'VarIsInitializedOp' operation.
    pub fn is_initialized(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'resource' Input of this 'VarIsInitializedOp' operation.
    pub fn resource(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<VarIsInitializedOpInst> for crate::Operation {
    fn from(inst: VarIsInitializedOpInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `VarIsInitializedOp::new().build(resource, scope)`.
pub fn var_is_initialized_op<O0: ::std::convert::Into<crate::Output>>(
    resource: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    VarIsInitializedOp::new().build(resource, scope)
}

/// Builder for the `Variable` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Variable {
    shape: ::std::option::Option<crate::Shape>,
    dtype: ::std::option::Option<crate::DataType>,
    container: ::std::option::Option<::std::string::String>,
    shared_name: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Variable' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct VariableInst {
    /// An instance of a fully built Variable Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Variable {
    /// Creates a new `Variable`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `shape` attribute.
    pub fn shape<ArgType: ::std::convert::Into<crate::Shape>>(mut self, value: ArgType) -> Self {
        self.shape = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `dtype` attribute.
    pub fn dtype<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `container` attribute.
    pub fn container<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.container = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shared_name` attribute.
    pub fn shared_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.shared_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Variable` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("Variable", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.shape {
                nd.set_attr_shape("shape", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                nd.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.container {
                nd.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                nd.set_attr_string("shared_name", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Variable' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(&self, scope: &mut crate::Scope) -> crate::Result<VariableInst> {
        let op = scope.new_operation("Variable", |builder| {
            if let ::std::option::Option::Some(value) = &self.shape {
                builder.set_attr_shape("shape", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                builder.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.container {
                builder.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                builder.set_attr_string("shared_name", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(VariableInst { op })
    }
}
impl VariableInst {
    /// Returns the 'ref_' Output of this 'Variable' operation.
    pub fn ref_(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
}
impl From<VariableInst> for crate::Operation {
    fn from(inst: VariableInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Variable::new().build(scope)`.
pub fn variable(scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
    Variable::new().build(scope)
}

/// Builder for the `VariableShape` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct VariableShape {
    out_type: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'VariableShape' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct VariableShapeInst {
    /// An instance of a fully built VariableShape Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl VariableShape {
    /// Creates a new `VariableShape`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `out_type` attribute.
    pub fn out_type<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.out_type = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `VariableShape` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("VariableShape", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.out_type {
                nd.set_attr_type("out_type", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'VariableShape' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<VariableShapeInst> {
        let op = scope.new_operation("VariableShape", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.out_type {
                builder.set_attr_type("out_type", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(VariableShapeInst { op })
    }
}
impl VariableShapeInst {
    /// Returns the 'output' Output of this 'VariableShape' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'VariableShape' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<VariableShapeInst> for crate::Operation {
    fn from(inst: VariableShapeInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `VariableShape::new().build(input, scope)`.
pub fn variable_shape<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    VariableShape::new().build(input, scope)
}

/// Builder for the `VariableV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct VariableV2 {
    shape: ::std::option::Option<crate::Shape>,
    dtype: ::std::option::Option<crate::DataType>,
    container: ::std::option::Option<::std::string::String>,
    shared_name: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'VariableV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct VariableV2Inst {
    /// An instance of a fully built VariableV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl VariableV2 {
    /// Creates a new `VariableV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `shape` attribute.
    pub fn shape<ArgType: ::std::convert::Into<crate::Shape>>(mut self, value: ArgType) -> Self {
        self.shape = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `dtype` attribute.
    pub fn dtype<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.dtype = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `container` attribute.
    pub fn container<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.container = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shared_name` attribute.
    pub fn shared_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.shared_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `VariableV2` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("VariableV2", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.shape {
                nd.set_attr_shape("shape", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                nd.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.container {
                nd.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                nd.set_attr_string("shared_name", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'VariableV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(&self, scope: &mut crate::Scope) -> crate::Result<VariableV2Inst> {
        let op = scope.new_operation("VariableV2", |builder| {
            if let ::std::option::Option::Some(value) = &self.shape {
                builder.set_attr_shape("shape", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.dtype {
                builder.set_attr_type("dtype", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.container {
                builder.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                builder.set_attr_string("shared_name", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(VariableV2Inst { op })
    }
}
impl VariableV2Inst {
    /// Returns the 'ref_' Output of this 'VariableV2' operation.
    pub fn ref_(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
}
impl From<VariableV2Inst> for crate::Operation {
    fn from(inst: VariableV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `VariableV2::new().build(scope)`.
pub fn variable_v2(scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
    VariableV2::new().build(scope)
}

/// Builder for the `Where` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Where {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Where' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct WhereInst {
    /// An instance of a fully built Where Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Where {
    /// Creates a new `Where`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Where` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Where", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Where' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<WhereInst> {
        let op = scope.new_operation("Where", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(WhereInst { op })
    }
}
impl WhereInst {
    /// Returns the 'index' Output of this 'Where' operation.
    pub fn index(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'Where' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<WhereInst> for crate::Operation {
    fn from(inst: WhereInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Where::new().build(input, scope)`.
pub fn where_<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Where::new().build(input, scope)
}

/// Builder for the `While` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct While {
    T: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    cond: ::std::option::Option<::std::string::String>,
    body: ::std::option::Option<::std::string::String>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    parallel_iterations: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'While' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct WhileInst {
    /// An instance of a fully built While Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl While {
    /// Creates a new `While`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `cond` attribute.
    pub fn cond<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.cond = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `body` attribute.
    pub fn body<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.body = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `parallel_iterations` attribute.
    pub fn parallel_iterations<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.parallel_iterations = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `While` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("While", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type_list("T", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.cond {
                nd.set_attr_string("cond", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.body {
                nd.set_attr_string("body", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.parallel_iterations {
                nd.set_attr_int("parallel_iterations", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'While' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<WhileInst> {
        let op = scope.new_operation("While", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type_list("T", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.cond {
                builder.set_attr_string("cond", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.body {
                builder.set_attr_string("body", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.parallel_iterations {
                builder.set_attr_int("parallel_iterations", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(WhileInst { op })
    }
}
impl WhileInst {
    /// Returns the 'output' Output of this 'While' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input' Input of this 'While' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<WhileInst> for crate::Operation {
    fn from(inst: WhileInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `While::new().build(input, scope)`.
pub fn while_<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    While::new().build(input, scope)
}

/// Builder for the `WholeFileReader` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct WholeFileReader {
    container: ::std::option::Option<::std::string::String>,
    shared_name: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'WholeFileReader' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct WholeFileReaderInst {
    /// An instance of a fully built WholeFileReader Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl WholeFileReader {
    /// Creates a new `WholeFileReader`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `container` attribute.
    pub fn container<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.container = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shared_name` attribute.
    pub fn shared_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.shared_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `WholeFileReader` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("WholeFileReader", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.container {
                nd.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                nd.set_attr_string("shared_name", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'WholeFileReader' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(&self, scope: &mut crate::Scope) -> crate::Result<WholeFileReaderInst> {
        let op = scope.new_operation("WholeFileReader", |builder| {
            if let ::std::option::Option::Some(value) = &self.container {
                builder.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                builder.set_attr_string("shared_name", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(WholeFileReaderInst { op })
    }
}
impl WholeFileReaderInst {
    /// Returns the 'reader_handle' Output of this 'WholeFileReader' operation.
    pub fn reader_handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
}
impl From<WholeFileReaderInst> for crate::Operation {
    fn from(inst: WholeFileReaderInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `WholeFileReader::new().build(scope)`.
pub fn whole_file_reader(scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
    WholeFileReader::new().build(scope)
}

/// Builder for the `WholeFileReaderV2` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct WholeFileReaderV2 {
    container: ::std::option::Option<::std::string::String>,
    shared_name: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'WholeFileReaderV2' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct WholeFileReaderV2Inst {
    /// An instance of a fully built WholeFileReaderV2 Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl WholeFileReaderV2 {
    /// Creates a new `WholeFileReaderV2`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `container` attribute.
    pub fn container<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.container = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shared_name` attribute.
    pub fn shared_name<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.shared_name = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `WholeFileReaderV2` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("WholeFileReaderV2", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.container {
                nd.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                nd.set_attr_string("shared_name", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'WholeFileReaderV2' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(&self, scope: &mut crate::Scope) -> crate::Result<WholeFileReaderV2Inst> {
        let op = scope.new_operation("WholeFileReaderV2", |builder| {
            if let ::std::option::Option::Some(value) = &self.container {
                builder.set_attr_string("container", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shared_name {
                builder.set_attr_string("shared_name", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(WholeFileReaderV2Inst { op })
    }
}
impl WholeFileReaderV2Inst {
    /// Returns the 'reader_handle' Output of this 'WholeFileReaderV2' operation.
    pub fn reader_handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
}
impl From<WholeFileReaderV2Inst> for crate::Operation {
    fn from(inst: WholeFileReaderV2Inst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `WholeFileReaderV2::new().build(scope)`.
pub fn whole_file_reader_v2(scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
    WholeFileReaderV2::new().build(scope)
}

/// Builder for the `WindowDataset` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct WindowDataset {
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    metadata: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'WindowDataset' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct WindowDatasetInst {
    /// An instance of a fully built WindowDataset Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl WindowDataset {
    /// Creates a new `WindowDataset`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `metadata` attribute.
    pub fn metadata<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.metadata = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `WindowDataset` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
    >(
        &self,
        input_dataset: O0,
        size: O1,
        shift: O2,
        stride: O3,
        drop_remainder: O4,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            input_dataset.into(),
            size.into(),
            shift.into(),
            stride.into(),
            drop_remainder.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        input_dataset: crate::Output,
        size: crate::Output,
        shift: crate::Output,
        stride: crate::Output,
        drop_remainder: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("WindowDataset", |nd| {
            nd.add_input(input_dataset);
            nd.add_input(size);
            nd.add_input(shift);
            nd.add_input(stride);
            nd.add_input(drop_remainder);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.metadata {
                nd.set_attr_string("metadata", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'WindowDataset' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_dataset: crate::Output,
        size: crate::Output,
        shift: crate::Output,
        stride: crate::Output,
        drop_remainder: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<WindowDatasetInst> {
        let op = scope.new_operation("WindowDataset", |builder| {
            builder.add_input(input_dataset);
            builder.add_input(size);
            builder.add_input(shift);
            builder.add_input(stride);
            builder.add_input(drop_remainder);
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.metadata {
                builder.set_attr_string("metadata", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(WindowDatasetInst { op })
    }
}
impl WindowDatasetInst {
    /// Returns the 'handle' Output of this 'WindowDataset' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_dataset' Input of this 'WindowDataset' operation.
    pub fn input_dataset(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'size' Input of this 'WindowDataset' operation.
    pub fn size(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'shift' Input of this 'WindowDataset' operation.
    pub fn shift(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'stride' Input of this 'WindowDataset' operation.
    pub fn stride(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'drop_remainder' Input of this 'WindowDataset' operation.
    pub fn drop_remainder(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
}
impl From<WindowDatasetInst> for crate::Operation {
    fn from(inst: WindowDatasetInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `WindowDataset::new().build(input_dataset, size, shift, stride, drop_remainder, scope)`.
pub fn window_dataset<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
>(
    input_dataset: O0,
    size: O1,
    shift: O2,
    stride: O3,
    drop_remainder: O4,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    WindowDataset::new().build(input_dataset, size, shift, stride, drop_remainder, scope)
}

/// Builder for the `WindowOp` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct WindowOp {
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    Tinputs: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'WindowOp' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct WindowOpInst {
    /// An instance of a fully built WindowOp Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl WindowOp {
    /// Creates a new `WindowOp`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Tinputs` attribute.
    pub fn Tinputs<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tinputs = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `WindowOp` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        inputs: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(inputs.into(), scope)
    }
    fn build_impl(
        &self,
        inputs: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("WindowOp", |nd| {
            nd.add_input(inputs);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tinputs {
                nd.set_attr_type_list("Tinputs", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'WindowOp' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        inputs: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<WindowOpInst> {
        let op = scope.new_operation("WindowOp", |builder| {
            builder.add_input(inputs);
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Tinputs {
                builder.set_attr_type_list("Tinputs", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(WindowOpInst { op })
    }
}
impl WindowOpInst {
    /// Returns the 'handle' Output of this 'WindowOp' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'inputs' Input of this 'WindowOp' operation.
    pub fn inputs(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<WindowOpInst> for crate::Operation {
    fn from(inst: WindowOpInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `WindowOp::new().build(inputs, scope)`.
pub fn window_op<O0: ::std::convert::Into<crate::Output>>(
    inputs: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    WindowOp::new().build(inputs, scope)
}

/// Builder for the `WorkerHeartbeat` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct WorkerHeartbeat {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'WorkerHeartbeat' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct WorkerHeartbeatInst {
    /// An instance of a fully built WorkerHeartbeat Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl WorkerHeartbeat {
    /// Creates a new `WorkerHeartbeat`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `WorkerHeartbeat` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        request: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(request.into(), scope)
    }
    fn build_impl(
        &self,
        request: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("WorkerHeartbeat", |nd| {
            nd.add_input(request);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'WorkerHeartbeat' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        request: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<WorkerHeartbeatInst> {
        let op = scope.new_operation("WorkerHeartbeat", |builder| {
            builder.add_input(request);
            ::std::result::Result::Ok(())
        })?;
        Ok(WorkerHeartbeatInst { op })
    }
}
impl WorkerHeartbeatInst {
    /// Returns the 'response' Output of this 'WorkerHeartbeat' operation.
    pub fn response(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'request' Input of this 'WorkerHeartbeat' operation.
    pub fn request(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<WorkerHeartbeatInst> for crate::Operation {
    fn from(inst: WorkerHeartbeatInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `WorkerHeartbeat::new().build(request, scope)`.
pub fn worker_heartbeat<O0: ::std::convert::Into<crate::Output>>(
    request: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    WorkerHeartbeat::new().build(request, scope)
}

/// Builder for the `WrapDatasetVariant` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct WrapDatasetVariant {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'WrapDatasetVariant' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct WrapDatasetVariantInst {
    /// An instance of a fully built WrapDatasetVariant Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl WrapDatasetVariant {
    /// Creates a new `WrapDatasetVariant`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `WrapDatasetVariant` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input_handle: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input_handle.into(), scope)
    }
    fn build_impl(
        &self,
        input_handle: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("WrapDatasetVariant", |nd| {
            nd.add_input(input_handle);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'WrapDatasetVariant' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_handle: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<WrapDatasetVariantInst> {
        let op = scope.new_operation("WrapDatasetVariant", |builder| {
            builder.add_input(input_handle);
            ::std::result::Result::Ok(())
        })?;
        Ok(WrapDatasetVariantInst { op })
    }
}
impl WrapDatasetVariantInst {
    /// Returns the 'output_handle' Output of this 'WrapDatasetVariant' operation.
    pub fn output_handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'input_handle' Input of this 'WrapDatasetVariant' operation.
    pub fn input_handle(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<WrapDatasetVariantInst> for crate::Operation {
    fn from(inst: WrapDatasetVariantInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `WrapDatasetVariant::new().build(input_handle, scope)`.
pub fn wrap_dataset_variant<O0: ::std::convert::Into<crate::Output>>(
    input_handle: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    WrapDatasetVariant::new().build(input_handle, scope)
}

/// Builder for the `WriteAudioSummary` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct WriteAudioSummary {
    max_outputs: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'WriteAudioSummary' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct WriteAudioSummaryInst {
    /// An instance of a fully built WriteAudioSummary Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl WriteAudioSummary {
    /// Creates a new `WriteAudioSummary`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `max_outputs` attribute.
    pub fn max_outputs<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.max_outputs = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `WriteAudioSummary` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
    >(
        &self,
        writer: O0,
        step: O1,
        tag: O2,
        tensor: O3,
        sample_rate: O4,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            writer.into(),
            step.into(),
            tag.into(),
            tensor.into(),
            sample_rate.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        writer: crate::Output,
        step: crate::Output,
        tag: crate::Output,
        tensor: crate::Output,
        sample_rate: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("WriteAudioSummary", |nd| {
            nd.add_input(writer);
            nd.add_input(step);
            nd.add_input(tag);
            nd.add_input(tensor);
            nd.add_input(sample_rate);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.max_outputs {
                nd.set_attr_int("max_outputs", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'WriteAudioSummary' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        writer: crate::Output,
        step: crate::Output,
        tag: crate::Output,
        tensor: crate::Output,
        sample_rate: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<WriteAudioSummaryInst> {
        let op = scope.new_operation("WriteAudioSummary", |builder| {
            builder.add_input(writer);
            builder.add_input(step);
            builder.add_input(tag);
            builder.add_input(tensor);
            builder.add_input(sample_rate);
            if let ::std::option::Option::Some(value) = &self.max_outputs {
                builder.set_attr_int("max_outputs", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(WriteAudioSummaryInst { op })
    }
}
impl WriteAudioSummaryInst {
    /// Returns the 'writer' Input of this 'WriteAudioSummary' operation.
    pub fn writer(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'step' Input of this 'WriteAudioSummary' operation.
    pub fn step(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'tag' Input of this 'WriteAudioSummary' operation.
    pub fn tag(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'tensor' Input of this 'WriteAudioSummary' operation.
    pub fn tensor(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'sample_rate' Input of this 'WriteAudioSummary' operation.
    pub fn sample_rate(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
}
impl From<WriteAudioSummaryInst> for crate::Operation {
    fn from(inst: WriteAudioSummaryInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `WriteAudioSummary::new().build(writer, step, tag, tensor, sample_rate, scope)`.
pub fn write_audio_summary<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
>(
    writer: O0,
    step: O1,
    tag: O2,
    tensor: O3,
    sample_rate: O4,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    WriteAudioSummary::new().build(writer, step, tag, tensor, sample_rate, scope)
}

/// Builder for the `WriteFile` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct WriteFile {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'WriteFile' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct WriteFileInst {
    /// An instance of a fully built WriteFile Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl WriteFile {
    /// Creates a new `WriteFile`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `WriteFile` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        filename: O0,
        contents: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(filename.into(), contents.into(), scope)
    }
    fn build_impl(
        &self,
        filename: crate::Output,
        contents: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("WriteFile", |nd| {
            nd.add_input(filename);
            nd.add_input(contents);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'WriteFile' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        filename: crate::Output,
        contents: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<WriteFileInst> {
        let op = scope.new_operation("WriteFile", |builder| {
            builder.add_input(filename);
            builder.add_input(contents);
            ::std::result::Result::Ok(())
        })?;
        Ok(WriteFileInst { op })
    }
}
impl WriteFileInst {
    /// Returns the 'filename' Input of this 'WriteFile' operation.
    pub fn filename(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'contents' Input of this 'WriteFile' operation.
    pub fn contents(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<WriteFileInst> for crate::Operation {
    fn from(inst: WriteFileInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `WriteFile::new().build(filename, contents, scope)`.
pub fn write_file<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
>(
    filename: O0,
    contents: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    WriteFile::new().build(filename, contents, scope)
}

/// Builder for the `WriteGraphSummary` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct WriteGraphSummary {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'WriteGraphSummary' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct WriteGraphSummaryInst {
    /// An instance of a fully built WriteGraphSummary Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl WriteGraphSummary {
    /// Creates a new `WriteGraphSummary`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `WriteGraphSummary` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        writer: O0,
        step: O1,
        tensor: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(writer.into(), step.into(), tensor.into(), scope)
    }
    fn build_impl(
        &self,
        writer: crate::Output,
        step: crate::Output,
        tensor: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("WriteGraphSummary", |nd| {
            nd.add_input(writer);
            nd.add_input(step);
            nd.add_input(tensor);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'WriteGraphSummary' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        writer: crate::Output,
        step: crate::Output,
        tensor: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<WriteGraphSummaryInst> {
        let op = scope.new_operation("WriteGraphSummary", |builder| {
            builder.add_input(writer);
            builder.add_input(step);
            builder.add_input(tensor);
            ::std::result::Result::Ok(())
        })?;
        Ok(WriteGraphSummaryInst { op })
    }
}
impl WriteGraphSummaryInst {
    /// Returns the 'writer' Input of this 'WriteGraphSummary' operation.
    pub fn writer(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'step' Input of this 'WriteGraphSummary' operation.
    pub fn step(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'tensor' Input of this 'WriteGraphSummary' operation.
    pub fn tensor(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<WriteGraphSummaryInst> for crate::Operation {
    fn from(inst: WriteGraphSummaryInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `WriteGraphSummary::new().build(writer, step, tensor, scope)`.
pub fn write_graph_summary<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    writer: O0,
    step: O1,
    tensor: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    WriteGraphSummary::new().build(writer, step, tensor, scope)
}

/// Builder for the `WriteHistogramSummary` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct WriteHistogramSummary {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'WriteHistogramSummary' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct WriteHistogramSummaryInst {
    /// An instance of a fully built WriteHistogramSummary Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl WriteHistogramSummary {
    /// Creates a new `WriteHistogramSummary`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `WriteHistogramSummary` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
    >(
        &self,
        writer: O0,
        step: O1,
        tag: O2,
        values: O3,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(writer.into(), step.into(), tag.into(), values.into(), scope)
    }
    fn build_impl(
        &self,
        writer: crate::Output,
        step: crate::Output,
        tag: crate::Output,
        values: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("WriteHistogramSummary", |nd| {
            nd.add_input(writer);
            nd.add_input(step);
            nd.add_input(tag);
            nd.add_input(values);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'WriteHistogramSummary' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        writer: crate::Output,
        step: crate::Output,
        tag: crate::Output,
        values: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<WriteHistogramSummaryInst> {
        let op = scope.new_operation("WriteHistogramSummary", |builder| {
            builder.add_input(writer);
            builder.add_input(step);
            builder.add_input(tag);
            builder.add_input(values);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(WriteHistogramSummaryInst { op })
    }
}
impl WriteHistogramSummaryInst {
    /// Returns the 'writer' Input of this 'WriteHistogramSummary' operation.
    pub fn writer(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'step' Input of this 'WriteHistogramSummary' operation.
    pub fn step(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'tag' Input of this 'WriteHistogramSummary' operation.
    pub fn tag(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'values' Input of this 'WriteHistogramSummary' operation.
    pub fn values(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
}
impl From<WriteHistogramSummaryInst> for crate::Operation {
    fn from(inst: WriteHistogramSummaryInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `WriteHistogramSummary::new().build(writer, step, tag, values, scope)`.
pub fn write_histogram_summary<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
>(
    writer: O0,
    step: O1,
    tag: O2,
    values: O3,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    WriteHistogramSummary::new().build(writer, step, tag, values, scope)
}

/// Builder for the `WriteImageSummary` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct WriteImageSummary {
    max_images: ::std::option::Option<i64>,
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'WriteImageSummary' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct WriteImageSummaryInst {
    /// An instance of a fully built WriteImageSummary Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl WriteImageSummary {
    /// Creates a new `WriteImageSummary`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `max_images` attribute.
    pub fn max_images<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.max_images = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `WriteImageSummary` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
    >(
        &self,
        writer: O0,
        step: O1,
        tag: O2,
        tensor: O3,
        bad_color: O4,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            writer.into(),
            step.into(),
            tag.into(),
            tensor.into(),
            bad_color.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        writer: crate::Output,
        step: crate::Output,
        tag: crate::Output,
        tensor: crate::Output,
        bad_color: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("WriteImageSummary", |nd| {
            nd.add_input(writer);
            nd.add_input(step);
            nd.add_input(tag);
            nd.add_input(tensor);
            nd.add_input(bad_color);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.max_images {
                nd.set_attr_int("max_images", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'WriteImageSummary' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        writer: crate::Output,
        step: crate::Output,
        tag: crate::Output,
        tensor: crate::Output,
        bad_color: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<WriteImageSummaryInst> {
        let op = scope.new_operation("WriteImageSummary", |builder| {
            builder.add_input(writer);
            builder.add_input(step);
            builder.add_input(tag);
            builder.add_input(tensor);
            builder.add_input(bad_color);
            if let ::std::option::Option::Some(value) = &self.max_images {
                builder.set_attr_int("max_images", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(WriteImageSummaryInst { op })
    }
}
impl WriteImageSummaryInst {
    /// Returns the 'writer' Input of this 'WriteImageSummary' operation.
    pub fn writer(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'step' Input of this 'WriteImageSummary' operation.
    pub fn step(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'tag' Input of this 'WriteImageSummary' operation.
    pub fn tag(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'tensor' Input of this 'WriteImageSummary' operation.
    pub fn tensor(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'bad_color' Input of this 'WriteImageSummary' operation.
    pub fn bad_color(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
}
impl From<WriteImageSummaryInst> for crate::Operation {
    fn from(inst: WriteImageSummaryInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `WriteImageSummary::new().build(writer, step, tag, tensor, bad_color, scope)`.
pub fn write_image_summary<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
>(
    writer: O0,
    step: O1,
    tag: O2,
    tensor: O3,
    bad_color: O4,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    WriteImageSummary::new().build(writer, step, tag, tensor, bad_color, scope)
}

/// Builder for the `WriteRawProtoSummary` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct WriteRawProtoSummary {
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'WriteRawProtoSummary' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct WriteRawProtoSummaryInst {
    /// An instance of a fully built WriteRawProtoSummary Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl WriteRawProtoSummary {
    /// Creates a new `WriteRawProtoSummary`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `WriteRawProtoSummary` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        writer: O0,
        step: O1,
        tensor: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(writer.into(), step.into(), tensor.into(), scope)
    }
    fn build_impl(
        &self,
        writer: crate::Output,
        step: crate::Output,
        tensor: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("WriteRawProtoSummary", |nd| {
            nd.add_input(writer);
            nd.add_input(step);
            nd.add_input(tensor);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'WriteRawProtoSummary' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        writer: crate::Output,
        step: crate::Output,
        tensor: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<WriteRawProtoSummaryInst> {
        let op = scope.new_operation("WriteRawProtoSummary", |builder| {
            builder.add_input(writer);
            builder.add_input(step);
            builder.add_input(tensor);
            ::std::result::Result::Ok(())
        })?;
        Ok(WriteRawProtoSummaryInst { op })
    }
}
impl WriteRawProtoSummaryInst {
    /// Returns the 'writer' Input of this 'WriteRawProtoSummary' operation.
    pub fn writer(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'step' Input of this 'WriteRawProtoSummary' operation.
    pub fn step(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'tensor' Input of this 'WriteRawProtoSummary' operation.
    pub fn tensor(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
}
impl From<WriteRawProtoSummaryInst> for crate::Operation {
    fn from(inst: WriteRawProtoSummaryInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `WriteRawProtoSummary::new().build(writer, step, tensor, scope)`.
pub fn write_raw_proto_summary<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    writer: O0,
    step: O1,
    tensor: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    WriteRawProtoSummary::new().build(writer, step, tensor, scope)
}

/// Builder for the `WriteScalarSummary` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct WriteScalarSummary {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'WriteScalarSummary' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct WriteScalarSummaryInst {
    /// An instance of a fully built WriteScalarSummary Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl WriteScalarSummary {
    /// Creates a new `WriteScalarSummary`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `WriteScalarSummary` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
    >(
        &self,
        writer: O0,
        step: O1,
        tag: O2,
        value: O3,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(writer.into(), step.into(), tag.into(), value.into(), scope)
    }
    fn build_impl(
        &self,
        writer: crate::Output,
        step: crate::Output,
        tag: crate::Output,
        value: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("WriteScalarSummary", |nd| {
            nd.add_input(writer);
            nd.add_input(step);
            nd.add_input(tag);
            nd.add_input(value);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'WriteScalarSummary' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        writer: crate::Output,
        step: crate::Output,
        tag: crate::Output,
        value: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<WriteScalarSummaryInst> {
        let op = scope.new_operation("WriteScalarSummary", |builder| {
            builder.add_input(writer);
            builder.add_input(step);
            builder.add_input(tag);
            builder.add_input(value);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(WriteScalarSummaryInst { op })
    }
}
impl WriteScalarSummaryInst {
    /// Returns the 'writer' Input of this 'WriteScalarSummary' operation.
    pub fn writer(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'step' Input of this 'WriteScalarSummary' operation.
    pub fn step(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'tag' Input of this 'WriteScalarSummary' operation.
    pub fn tag(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'value' Input of this 'WriteScalarSummary' operation.
    pub fn value(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
}
impl From<WriteScalarSummaryInst> for crate::Operation {
    fn from(inst: WriteScalarSummaryInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `WriteScalarSummary::new().build(writer, step, tag, value, scope)`.
pub fn write_scalar_summary<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
>(
    writer: O0,
    step: O1,
    tag: O2,
    value: O3,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    WriteScalarSummary::new().build(writer, step, tag, value, scope)
}

/// Builder for the `WriteSummary` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct WriteSummary {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'WriteSummary' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct WriteSummaryInst {
    /// An instance of a fully built WriteSummary Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl WriteSummary {
    /// Creates a new `WriteSummary`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `WriteSummary` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
        O3: ::std::convert::Into<crate::Output>,
        O4: ::std::convert::Into<crate::Output>,
    >(
        &self,
        writer: O0,
        step: O1,
        tensor: O2,
        tag: O3,
        summary_metadata: O4,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            writer.into(),
            step.into(),
            tensor.into(),
            tag.into(),
            summary_metadata.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        writer: crate::Output,
        step: crate::Output,
        tensor: crate::Output,
        tag: crate::Output,
        summary_metadata: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("WriteSummary", |nd| {
            nd.add_input(writer);
            nd.add_input(step);
            nd.add_input(tensor);
            nd.add_input(tag);
            nd.add_input(summary_metadata);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'WriteSummary' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        writer: crate::Output,
        step: crate::Output,
        tensor: crate::Output,
        tag: crate::Output,
        summary_metadata: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<WriteSummaryInst> {
        let op = scope.new_operation("WriteSummary", |builder| {
            builder.add_input(writer);
            builder.add_input(step);
            builder.add_input(tensor);
            builder.add_input(tag);
            builder.add_input(summary_metadata);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(WriteSummaryInst { op })
    }
}
impl WriteSummaryInst {
    /// Returns the 'writer' Input of this 'WriteSummary' operation.
    pub fn writer(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'step' Input of this 'WriteSummary' operation.
    pub fn step(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
    /// Returns the 'tensor' Input of this 'WriteSummary' operation.
    pub fn tensor(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 2,
        }
    }
    /// Returns the 'tag' Input of this 'WriteSummary' operation.
    pub fn tag(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 3,
        }
    }
    /// Returns the 'summary_metadata' Input of this 'WriteSummary' operation.
    pub fn summary_metadata(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 4,
        }
    }
}
impl From<WriteSummaryInst> for crate::Operation {
    fn from(inst: WriteSummaryInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `WriteSummary::new().build(writer, step, tensor, tag, summary_metadata, scope)`.
pub fn write_summary<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
    O3: ::std::convert::Into<crate::Output>,
    O4: ::std::convert::Into<crate::Output>,
>(
    writer: O0,
    step: O1,
    tensor: O2,
    tag: O3,
    summary_metadata: O4,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    WriteSummary::new().build(writer, step, tensor, tag, summary_metadata, scope)
}

/// Builder for the `Xdivy` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Xdivy {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Xdivy' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct XdivyInst {
    /// An instance of a fully built Xdivy Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Xdivy {
    /// Creates a new `Xdivy`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Xdivy` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        x: O0,
        y: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), y.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        y: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Xdivy", |nd| {
            nd.add_input(x);
            nd.add_input(y);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Xdivy' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        y: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<XdivyInst> {
        let op = scope.new_operation("Xdivy", |builder| {
            builder.add_input(x);
            builder.add_input(y);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(XdivyInst { op })
    }
}
impl XdivyInst {
    /// Returns the 'z' Output of this 'Xdivy' operation.
    pub fn z(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'Xdivy' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'y' Input of this 'Xdivy' operation.
    pub fn y(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<XdivyInst> for crate::Operation {
    fn from(inst: XdivyInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Xdivy::new().build(x, y, scope)`.
pub fn xdivy<O0: ::std::convert::Into<crate::Output>, O1: ::std::convert::Into<crate::Output>>(
    x: O0,
    y: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Xdivy::new().build(x, y, scope)
}

/// Builder for the `XlaConcatND` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct XlaConcatND {
    T: ::std::option::Option<crate::DataType>,
    N: ::std::option::Option<i64>,
    num_concats: ::std::option::Option<::std::vec::Vec<i64>>,
    paddings: ::std::option::Option<::std::vec::Vec<i64>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'XlaConcatND' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct XlaConcatNDInst {
    /// An instance of a fully built XlaConcatND Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl XlaConcatND {
    /// Creates a new `XlaConcatND`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `N` attribute.
    pub fn N<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.N = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `num_concats` attribute.
    pub fn num_concats<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.num_concats = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `paddings` attribute.
    pub fn paddings<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.paddings = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `XlaConcatND` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        inputs: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(inputs.into(), scope)
    }
    fn build_impl(
        &self,
        inputs: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("XlaConcatND", |nd| {
            nd.add_input(inputs);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.N {
                nd.set_attr_int("N", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_concats {
                nd.set_attr_int_list("num_concats", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.paddings {
                nd.set_attr_int_list("paddings", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'XlaConcatND' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        inputs: Vec<crate::Output>,
        scope: &mut crate::Scope,
    ) -> crate::Result<XlaConcatNDInst> {
        let op = scope.new_operation("XlaConcatND", |builder| {
            builder.add_input_list(&inputs);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            builder.set_attr_int("N", inputs.clone().len() as i64)?;
            if let ::std::option::Option::Some(value) = &self.num_concats {
                builder.set_attr_int_list("num_concats", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.paddings {
                builder.set_attr_int_list("paddings", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(XlaConcatNDInst { op })
    }
}
impl XlaConcatNDInst {
    /// Returns the 'output' Output of this 'XlaConcatND' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns a Vector of inputs for 'inputs' Input of this XlaConcatND operation.
    pub fn inputs(&self) -> crate::Result<Vec<crate::Input>> {
        let mut Inputs = vec![];
        for i in 0..self.op.get_attr_int("N")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
}
impl From<XlaConcatNDInst> for crate::Operation {
    fn from(inst: XlaConcatNDInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `XlaConcatND::new().build(inputs, scope)`.
pub fn xla_concat_nd<O0: ::std::convert::Into<crate::Output>>(
    inputs: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    XlaConcatND::new().build(inputs, scope)
}

/// Builder for the `XlaHostCompute` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct XlaHostCompute {
    Tinputs: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    Toutputs: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    ancestors: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
    shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    shape_inference_graph: ::std::option::Option<::std::string::String>,
    key: ::std::option::Option<::std::string::String>,
    send_key: ::std::option::Option<::std::string::String>,
    recv_key: ::std::option::Option<::std::string::String>,
    cost_estimate_ns: ::std::option::Option<i64>,
    tpu_core: ::std::option::Option<i64>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'XlaHostCompute' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct XlaHostComputeInst {
    /// An instance of a fully built XlaHostCompute Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl XlaHostCompute {
    /// Creates a new `XlaHostCompute`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `Tinputs` attribute.
    pub fn Tinputs<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tinputs = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `Toutputs` attribute.
    pub fn Toutputs<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Toutputs = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `ancestors` attribute.
    pub fn ancestors<ArgType: ::std::convert::Into<::std::vec::Vec<::std::string::String>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.ancestors = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shapes` attribute.
    pub fn shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shape_inference_graph` attribute.
    pub fn shape_inference_graph<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.shape_inference_graph = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `key` attribute.
    pub fn key<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.key = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `send_key` attribute.
    pub fn send_key<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.send_key = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `recv_key` attribute.
    pub fn recv_key<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.recv_key = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `cost_estimate_ns` attribute.
    pub fn cost_estimate_ns<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.cost_estimate_ns = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `tpu_core` attribute.
    pub fn tpu_core<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.tpu_core = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `XlaHostCompute` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        inputs: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(inputs.into(), scope)
    }
    fn build_impl(
        &self,
        inputs: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("XlaHostCompute", |nd| {
            nd.add_input(inputs);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.Tinputs {
                nd.set_attr_type_list("Tinputs", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Toutputs {
                nd.set_attr_type_list("Toutputs", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.ancestors {
                nd.set_attr_string_list("ancestors", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shapes {
                nd.set_attr_shape_list("shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shape_inference_graph {
                nd.set_attr_string("shape_inference_graph", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.key {
                nd.set_attr_string("key", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.send_key {
                nd.set_attr_string("send_key", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.recv_key {
                nd.set_attr_string("recv_key", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.cost_estimate_ns {
                nd.set_attr_int("cost_estimate_ns", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.tpu_core {
                nd.set_attr_int("tpu_core", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'XlaHostCompute' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        inputs: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<XlaHostComputeInst> {
        let op = scope.new_operation("XlaHostCompute", |builder| {
            builder.add_input(inputs);
            if let ::std::option::Option::Some(value) = &self.Tinputs {
                builder.set_attr_type_list("Tinputs", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.Toutputs {
                builder.set_attr_type_list("Toutputs", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.ancestors {
                builder.set_attr_string_list("ancestors", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shapes {
                builder.set_attr_shape_list("shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shape_inference_graph {
                builder.set_attr_string("shape_inference_graph", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.key {
                builder.set_attr_string("key", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.send_key {
                builder.set_attr_string("send_key", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.recv_key {
                builder.set_attr_string("recv_key", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.cost_estimate_ns {
                builder.set_attr_int("cost_estimate_ns", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.tpu_core {
                builder.set_attr_int("tpu_core", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(XlaHostComputeInst { op })
    }
}
impl XlaHostComputeInst {
    /// Returns the 'outputs' Output of this 'XlaHostCompute' operation.
    pub fn outputs(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'inputs' Input of this 'XlaHostCompute' operation.
    pub fn inputs(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<XlaHostComputeInst> for crate::Operation {
    fn from(inst: XlaHostComputeInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `XlaHostCompute::new().build(inputs, scope)`.
pub fn xla_host_compute<O0: ::std::convert::Into<crate::Output>>(
    inputs: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    XlaHostCompute::new().build(inputs, scope)
}

/// Builder for the `XlaRecvFromHost` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct XlaRecvFromHost {
    Toutput: ::std::option::Option<crate::DataType>,
    shape: ::std::option::Option<crate::Shape>,
    key: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'XlaRecvFromHost' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct XlaRecvFromHostInst {
    /// An instance of a fully built XlaRecvFromHost Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl XlaRecvFromHost {
    /// Creates a new `XlaRecvFromHost`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `Toutput` attribute.
    pub fn Toutput<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Toutput = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `shape` attribute.
    pub fn shape<ArgType: ::std::convert::Into<crate::Shape>>(mut self, value: ArgType) -> Self {
        self.shape = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `key` attribute.
    pub fn key<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.key = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `XlaRecvFromHost` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("XlaRecvFromHost", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.Toutput {
                nd.set_attr_type("Toutput", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shape {
                nd.set_attr_shape("shape", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.key {
                nd.set_attr_string("key", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'XlaRecvFromHost' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(&self, scope: &mut crate::Scope) -> crate::Result<XlaRecvFromHostInst> {
        let op = scope.new_operation("XlaRecvFromHost", |builder| {
            if let ::std::option::Option::Some(value) = &self.Toutput {
                builder.set_attr_type("Toutput", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.shape {
                builder.set_attr_shape("shape", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.key {
                builder.set_attr_string("key", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(XlaRecvFromHostInst { op })
    }
}
impl XlaRecvFromHostInst {
    /// Returns the 'output' Output of this 'XlaRecvFromHost' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
}
impl From<XlaRecvFromHostInst> for crate::Operation {
    fn from(inst: XlaRecvFromHostInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `XlaRecvFromHost::new().build(scope)`.
pub fn xla_recv_from_host(scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
    XlaRecvFromHost::new().build(scope)
}

/// Builder for the `XlaRecvTPUEmbeddingActivations` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct XlaRecvTPUEmbeddingActivations {
    num_tables: ::std::option::Option<i64>,
    config: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'XlaRecvTPUEmbeddingActivations' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct XlaRecvTPUEmbeddingActivationsInst {
    /// An instance of a fully built XlaRecvTPUEmbeddingActivations Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl XlaRecvTPUEmbeddingActivations {
    /// Creates a new `XlaRecvTPUEmbeddingActivations`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `num_tables` attribute.
    pub fn num_tables<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.num_tables = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `config` attribute.
    pub fn config<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.config = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `XlaRecvTPUEmbeddingActivations` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        deduplication_data: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(deduplication_data.into(), scope)
    }
    fn build_impl(
        &self,
        deduplication_data: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("XlaRecvTPUEmbeddingActivations", |nd| {
            nd.add_input(deduplication_data);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.num_tables {
                nd.set_attr_int("num_tables", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.config {
                nd.set_attr_string("config", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'XlaRecvTPUEmbeddingActivations' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        deduplication_data: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<XlaRecvTPUEmbeddingActivationsInst> {
        let op = scope.new_operation("XlaRecvTPUEmbeddingActivations", |builder| {
            builder.add_input(deduplication_data);
            if let ::std::option::Option::Some(value) = &self.num_tables {
                builder.set_attr_int("num_tables", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.config {
                builder.set_attr_string("config", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(XlaRecvTPUEmbeddingActivationsInst { op })
    }
}
impl XlaRecvTPUEmbeddingActivationsInst {
    /// Returns a Vector of outputs for 'outputs' Output of this XlaRecvTPUEmbeddingActivations operation.
    pub fn outputs(&self) -> crate::Result<Vec<crate::Output>> {
        let mut Outputs = vec![];
        for i in 0..self.op.get_attr_int("num_tables")? as i32 {
            Outputs.push(crate::Output {
                operation: self.op.clone(),
                index: i,
            });
        }
        Ok(Outputs)
    }
    /// Returns the 'deduplication_data' Input of this 'XlaRecvTPUEmbeddingActivations' operation.
    pub fn deduplication_data(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<XlaRecvTPUEmbeddingActivationsInst> for crate::Operation {
    fn from(inst: XlaRecvTPUEmbeddingActivationsInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `XlaRecvTPUEmbeddingActivations::new().build(deduplication_data, scope)`.
pub fn xla_recv_tpuembedding_activations<O0: ::std::convert::Into<crate::Output>>(
    deduplication_data: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    XlaRecvTPUEmbeddingActivations::new().build(deduplication_data, scope)
}

/// Builder for the `XlaRecvTPUEmbeddingDeduplicationData` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct XlaRecvTPUEmbeddingDeduplicationData {
    config: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'XlaRecvTPUEmbeddingDeduplicationData' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct XlaRecvTPUEmbeddingDeduplicationDataInst {
    /// An instance of a fully built XlaRecvTPUEmbeddingDeduplicationData Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl XlaRecvTPUEmbeddingDeduplicationData {
    /// Creates a new `XlaRecvTPUEmbeddingDeduplicationData`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `config` attribute.
    pub fn config<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.config = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `XlaRecvTPUEmbeddingDeduplicationData` operation.
    pub fn build(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        self.build_impl(scope)
    }
    fn build_impl(&self, scope: &mut crate::Scope) -> crate::Result<crate::Operation> {
        scope.new_operation("XlaRecvTPUEmbeddingDeduplicationData", |nd| {
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.config {
                nd.set_attr_string("config", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'XlaRecvTPUEmbeddingDeduplicationData' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        scope: &mut crate::Scope,
    ) -> crate::Result<XlaRecvTPUEmbeddingDeduplicationDataInst> {
        let op = scope.new_operation("XlaRecvTPUEmbeddingDeduplicationData", |builder| {
            if let ::std::option::Option::Some(value) = &self.config {
                builder.set_attr_string("config", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(XlaRecvTPUEmbeddingDeduplicationDataInst { op })
    }
}
impl XlaRecvTPUEmbeddingDeduplicationDataInst {
    /// Returns the 'output' Output of this 'XlaRecvTPUEmbeddingDeduplicationData' operation.
    pub fn output(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
}
impl From<XlaRecvTPUEmbeddingDeduplicationDataInst> for crate::Operation {
    fn from(inst: XlaRecvTPUEmbeddingDeduplicationDataInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `XlaRecvTPUEmbeddingDeduplicationData::new().build(scope)`.
pub fn xla_recv_tpuembedding_deduplication_data(
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    XlaRecvTPUEmbeddingDeduplicationData::new().build(scope)
}

/// Builder for the `XlaSendTPUEmbeddingGradients` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct XlaSendTPUEmbeddingGradients {
    NumTables: ::std::option::Option<i64>,
    NumLearningRateTags: ::std::option::Option<i64>,
    config: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'XlaSendTPUEmbeddingGradients' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct XlaSendTPUEmbeddingGradientsInst {
    /// An instance of a fully built XlaSendTPUEmbeddingGradients Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl XlaSendTPUEmbeddingGradients {
    /// Creates a new `XlaSendTPUEmbeddingGradients`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `NumTables` attribute.
    pub fn NumTables<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.NumTables = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `NumLearningRateTags` attribute.
    pub fn NumLearningRateTags<ArgType: ::std::convert::Into<i64>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.NumLearningRateTags = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `config` attribute.
    pub fn config<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.config = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `XlaSendTPUEmbeddingGradients` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
        O2: ::std::convert::Into<crate::Output>,
    >(
        &self,
        gradients: O0,
        learning_rates: O1,
        deduplication_data: O2,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(
            gradients.into(),
            learning_rates.into(),
            deduplication_data.into(),
            scope,
        )
    }
    fn build_impl(
        &self,
        gradients: crate::Output,
        learning_rates: crate::Output,
        deduplication_data: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("XlaSendTPUEmbeddingGradients", |nd| {
            nd.add_input(gradients);
            nd.add_input(learning_rates);
            nd.add_input(deduplication_data);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.NumTables {
                nd.set_attr_int("NumTables", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.NumLearningRateTags {
                nd.set_attr_int("NumLearningRateTags", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.config {
                nd.set_attr_string("config", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'XlaSendTPUEmbeddingGradients' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        gradients: Vec<crate::Output>,
        learning_rates: Vec<crate::Output>,
        deduplication_data: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<XlaSendTPUEmbeddingGradientsInst> {
        let op = scope.new_operation("XlaSendTPUEmbeddingGradients", |builder| {
            builder.add_input_list(&gradients);
            builder.add_input_list(&learning_rates);
            builder.add_input(deduplication_data);
            builder.set_attr_int("NumTables", gradients.clone().len() as i64)?;
            builder.set_attr_int("NumLearningRateTags", learning_rates.clone().len() as i64)?;
            if let ::std::option::Option::Some(value) = &self.config {
                builder.set_attr_string("config", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(XlaSendTPUEmbeddingGradientsInst { op })
    }
}
impl XlaSendTPUEmbeddingGradientsInst {
    /// Returns a Vector of gradients for 'gradients' Input of this XlaSendTPUEmbeddingGradients operation.
    pub fn gradients(&self) -> crate::Result<Vec<crate::Input>> {
        let mut Inputs = vec![];
        for i in 0..self.op.get_attr_int("NumTables")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
    /// Returns a Vector of learning_rates for 'learning_rates' Input of this XlaSendTPUEmbeddingGradients operation.
    pub fn learning_rates(&self) -> crate::Result<Vec<crate::Input>> {
        let dynamic_offset = (self.op.get_attr_int("NumTables")? + 1) as i32;
        let mut Inputs = vec![];
        for i in
            dynamic_offset..dynamic_offset + self.op.get_attr_int("NumLearningRateTags")? as i32
        {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
    /// Returns the 'deduplication_data' Input of this 'XlaSendTPUEmbeddingGradients' operation.
    pub fn deduplication_data(&self) -> crate::Result<crate::Input> {
        let dynamic_offset = (self.op.get_attr_int("NumTables")?
            + self.op.get_attr_int("NumLearningRateTags")?
            + 2) as i32;
        Ok(crate::Input {
            operation: &self.op,
            index: dynamic_offset,
        })
    }
}
impl From<XlaSendTPUEmbeddingGradientsInst> for crate::Operation {
    fn from(inst: XlaSendTPUEmbeddingGradientsInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `XlaSendTPUEmbeddingGradients::new().build(gradients, learning_rates, deduplication_data, scope)`.
pub fn xla_send_tpuembedding_gradients<
    O0: ::std::convert::Into<crate::Output>,
    O1: ::std::convert::Into<crate::Output>,
    O2: ::std::convert::Into<crate::Output>,
>(
    gradients: O0,
    learning_rates: O1,
    deduplication_data: O2,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    XlaSendTPUEmbeddingGradients::new().build(gradients, learning_rates, deduplication_data, scope)
}

/// Builder for the `XlaSendToHost` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct XlaSendToHost {
    Tinput: ::std::option::Option<crate::DataType>,
    key: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'XlaSendToHost' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct XlaSendToHostInst {
    /// An instance of a fully built XlaSendToHost Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl XlaSendToHost {
    /// Creates a new `XlaSendToHost`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `Tinput` attribute.
    pub fn Tinput<ArgType: ::std::convert::Into<crate::DataType>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.Tinput = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `key` attribute.
    pub fn key<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.key = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `XlaSendToHost` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("XlaSendToHost", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.Tinput {
                nd.set_attr_type("Tinput", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.key {
                nd.set_attr_string("key", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'XlaSendToHost' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<XlaSendToHostInst> {
        let op = scope.new_operation("XlaSendToHost", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.Tinput {
                builder.set_attr_type("Tinput", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.key {
                builder.set_attr_string("key", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(XlaSendToHostInst { op })
    }
}
impl XlaSendToHostInst {
    /// Returns the 'input' Input of this 'XlaSendToHost' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<XlaSendToHostInst> for crate::Operation {
    fn from(inst: XlaSendToHostInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `XlaSendToHost::new().build(input, scope)`.
pub fn xla_send_to_host<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    XlaSendToHost::new().build(input, scope)
}

/// Builder for the `XlaSplitND` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct XlaSplitND {
    T: ::std::option::Option<crate::DataType>,
    N: ::std::option::Option<i64>,
    num_splits: ::std::option::Option<::std::vec::Vec<i64>>,
    paddings: ::std::option::Option<::std::vec::Vec<i64>>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'XlaSplitND' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct XlaSplitNDInst {
    /// An instance of a fully built XlaSplitND Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl XlaSplitND {
    /// Creates a new `XlaSplitND`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `N` attribute.
    pub fn N<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.N = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `num_splits` attribute.
    pub fn num_splits<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.num_splits = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `paddings` attribute.
    pub fn paddings<ArgType: ::std::convert::Into<::std::vec::Vec<i64>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.paddings = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `XlaSplitND` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input.into(), scope)
    }
    fn build_impl(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("XlaSplitND", |nd| {
            nd.add_input(input);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.N {
                nd.set_attr_int("N", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_splits {
                nd.set_attr_int_list("num_splits", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.paddings {
                nd.set_attr_int_list("paddings", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'XlaSplitND' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<XlaSplitNDInst> {
        let op = scope.new_operation("XlaSplitND", |builder| {
            builder.add_input(input);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.N {
                builder.set_attr_int("N", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.num_splits {
                builder.set_attr_int_list("num_splits", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.paddings {
                builder.set_attr_int_list("paddings", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(XlaSplitNDInst { op })
    }
}
impl XlaSplitNDInst {
    /// Returns a Vector of outputs for 'outputs' Output of this XlaSplitND operation.
    pub fn outputs(&self) -> crate::Result<Vec<crate::Output>> {
        let mut Outputs = vec![];
        for i in 0..self.op.get_attr_int("N")? as i32 {
            Outputs.push(crate::Output {
                operation: self.op.clone(),
                index: i,
            });
        }
        Ok(Outputs)
    }
    /// Returns the 'input' Input of this 'XlaSplitND' operation.
    pub fn input(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<XlaSplitNDInst> for crate::Operation {
    fn from(inst: XlaSplitNDInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `XlaSplitND::new().build(input, scope)`.
pub fn xla_split_nd<O0: ::std::convert::Into<crate::Output>>(
    input: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    XlaSplitND::new().build(input, scope)
}

/// Builder for the `Xlog1py` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Xlog1py {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Xlog1py' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct Xlog1pyInst {
    /// An instance of a fully built Xlog1py Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Xlog1py {
    /// Creates a new `Xlog1py`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Xlog1py` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        x: O0,
        y: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), y.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        y: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Xlog1py", |nd| {
            nd.add_input(x);
            nd.add_input(y);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Xlog1py' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        y: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<Xlog1pyInst> {
        let op = scope.new_operation("Xlog1py", |builder| {
            builder.add_input(x);
            builder.add_input(y);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(Xlog1pyInst { op })
    }
}
impl Xlog1pyInst {
    /// Returns the 'z' Output of this 'Xlog1py' operation.
    pub fn z(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'Xlog1py' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'y' Input of this 'Xlog1py' operation.
    pub fn y(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<Xlog1pyInst> for crate::Operation {
    fn from(inst: Xlog1pyInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Xlog1py::new().build(x, y, scope)`.
pub fn xlog1py<O0: ::std::convert::Into<crate::Output>, O1: ::std::convert::Into<crate::Output>>(
    x: O0,
    y: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Xlog1py::new().build(x, y, scope)
}

/// Builder for the `Xlogy` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Xlogy {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Xlogy' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct XlogyInst {
    /// An instance of a fully built Xlogy Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Xlogy {
    /// Creates a new `Xlogy`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Xlogy` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        x: O0,
        y: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), y.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        y: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Xlogy", |nd| {
            nd.add_input(x);
            nd.add_input(y);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Xlogy' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        y: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<XlogyInst> {
        let op = scope.new_operation("Xlogy", |builder| {
            builder.add_input(x);
            builder.add_input(y);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(XlogyInst { op })
    }
}
impl XlogyInst {
    /// Returns the 'z' Output of this 'Xlogy' operation.
    pub fn z(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'Xlogy' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'y' Input of this 'Xlogy' operation.
    pub fn y(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<XlogyInst> for crate::Operation {
    fn from(inst: XlogyInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Xlogy::new().build(x, y, scope)`.
pub fn xlogy<O0: ::std::convert::Into<crate::Output>, O1: ::std::convert::Into<crate::Output>>(
    x: O0,
    y: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Xlogy::new().build(x, y, scope)
}

/// Builder for the `ZerosLike` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ZerosLike {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ZerosLike' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ZerosLikeInst {
    /// An instance of a fully built ZerosLike Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ZerosLike {
    /// Creates a new `ZerosLike`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ZerosLike` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        x: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ZerosLike", |nd| {
            nd.add_input(x);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ZerosLike' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ZerosLikeInst> {
        let op = scope.new_operation("ZerosLike", |builder| {
            builder.add_input(x);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ZerosLikeInst { op })
    }
}
impl ZerosLikeInst {
    /// Returns the 'y' Output of this 'ZerosLike' operation.
    pub fn y(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'ZerosLike' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
}
impl From<ZerosLikeInst> for crate::Operation {
    fn from(inst: ZerosLikeInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ZerosLike::new().build(x, scope)`.
pub fn zeros_like<O0: ::std::convert::Into<crate::Output>>(
    x: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ZerosLike::new().build(x, scope)
}

/// Builder for the `Zeta` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct Zeta {
    T: ::std::option::Option<crate::DataType>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'Zeta' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ZetaInst {
    /// An instance of a fully built Zeta Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl Zeta {
    /// Creates a new `Zeta`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `T` attribute.
    pub fn T<ArgType: ::std::convert::Into<crate::DataType>>(mut self, value: ArgType) -> Self {
        self.T = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `Zeta` operation.
    pub fn build<
        O0: ::std::convert::Into<crate::Output>,
        O1: ::std::convert::Into<crate::Output>,
    >(
        &self,
        x: O0,
        q: O1,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(x.into(), q.into(), scope)
    }
    fn build_impl(
        &self,
        x: crate::Output,
        q: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("Zeta", |nd| {
            nd.add_input(x);
            nd.add_input(q);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.T {
                nd.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'Zeta' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        x: crate::Output,
        q: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<ZetaInst> {
        let op = scope.new_operation("Zeta", |builder| {
            builder.add_input(x);
            builder.add_input(q);
            if let ::std::option::Option::Some(value) = &self.T {
                builder.set_attr_type("T", *value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ZetaInst { op })
    }
}
impl ZetaInst {
    /// Returns the 'z' Output of this 'Zeta' operation.
    pub fn z(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns the 'x' Input of this 'Zeta' operation.
    pub fn x(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 0,
        }
    }
    /// Returns the 'q' Input of this 'Zeta' operation.
    pub fn q(&self) -> crate::Input {
        crate::Input {
            operation: &self.op,
            index: 1,
        }
    }
}
impl From<ZetaInst> for crate::Operation {
    fn from(inst: ZetaInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `Zeta::new().build(x, q, scope)`.
pub fn zeta<O0: ::std::convert::Into<crate::Output>, O1: ::std::convert::Into<crate::Output>>(
    x: O0,
    q: O1,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    Zeta::new().build(x, q, scope)
}

/// Builder for the `ZipDataset` operation.
#[derive(::std::fmt::Debug, ::std::default::Default)]
pub struct ZipDataset {
    output_types: ::std::option::Option<::std::vec::Vec<crate::DataType>>,
    output_shapes: ::std::option::Option<::std::vec::Vec<crate::Shape>>,
    N: ::std::option::Option<i64>,
    metadata: ::std::option::Option<::std::string::String>,
    control_inputs: ::std::vec::Vec<crate::Operation>,
}
/// An instance of 'ZipDataset' Operation with it's Outputs and Inputs exposed as methods.
#[derive(Debug, Clone)]
pub struct ZipDatasetInst {
    /// An instance of a fully built ZipDataset Operation in a Tensorflow graph.
    pub op: crate::Operation,
}

impl ZipDataset {
    /// Creates a new `ZipDataset`.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the `output_types` attribute.
    pub fn output_types<ArgType: ::std::convert::Into<::std::vec::Vec<crate::DataType>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_types = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `output_shapes` attribute.
    pub fn output_shapes<ArgType: ::std::convert::Into<::std::vec::Vec<crate::Shape>>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.output_shapes = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `N` attribute.
    pub fn N<ArgType: ::std::convert::Into<i64>>(mut self, value: ArgType) -> Self {
        self.N = ::std::option::Option::Some(value.into());
        self
    }

    /// Sets the `metadata` attribute.
    pub fn metadata<ArgType: ::std::convert::Into<::std::string::String>>(
        mut self,
        value: ArgType,
    ) -> Self {
        self.metadata = ::std::option::Option::Some(value.into());
        self
    }

    /// Adds a control input.
    pub fn add_control_input(mut self, op: crate::Operation) -> Self {
        self.control_inputs.push(op);
        self
    }

    /// Builds the `ZipDataset` operation.
    pub fn build<O0: ::std::convert::Into<crate::Output>>(
        &self,
        input_datasets: O0,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        self.build_impl(input_datasets.into(), scope)
    }
    fn build_impl(
        &self,
        input_datasets: crate::Output,
        scope: &mut crate::Scope,
    ) -> crate::Result<crate::Operation> {
        scope.new_operation("ZipDataset", |nd| {
            nd.add_input(input_datasets);
            for op in &self.control_inputs {
                nd.add_control_input(op);
            }
            if let ::std::option::Option::Some(value) = &self.output_types {
                nd.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                nd.set_attr_shape_list("output_shapes", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.N {
                nd.set_attr_int("N", *value)?;
            }
            if let ::std::option::Option::Some(value) = &self.metadata {
                nd.set_attr_string("metadata", value)?;
            }
            ::std::result::Result::Ok(())
        })
    }

    /// Builds a new instance of 'ZipDataset' Operation with it's Outputs and Inputs exposed as methods.
    pub fn build_instance(
        &self,
        input_datasets: Vec<crate::Output>,
        scope: &mut crate::Scope,
    ) -> crate::Result<ZipDatasetInst> {
        let op = scope.new_operation("ZipDataset", |builder| {
            builder.add_input_list(&input_datasets);
            if let ::std::option::Option::Some(value) = &self.output_types {
                builder.set_attr_type_list("output_types", value)?;
            }
            if let ::std::option::Option::Some(value) = &self.output_shapes {
                builder.set_attr_shape_list("output_shapes", value)?;
            }
            builder.set_attr_int("N", input_datasets.clone().len() as i64)?;
            if let ::std::option::Option::Some(value) = &self.metadata {
                builder.set_attr_string("metadata", value)?;
            }
            ::std::result::Result::Ok(())
        })?;
        Ok(ZipDatasetInst { op })
    }
}
impl ZipDatasetInst {
    /// Returns the 'handle' Output of this 'ZipDataset' operation.
    pub fn handle(&self) -> crate::Output {
        crate::Output {
            operation: self.op.clone(),
            index: 0,
        }
    }
    /// Returns a Vector of input_datasets for 'input_datasets' Input of this ZipDataset operation.
    pub fn input_datasets(&self) -> crate::Result<Vec<crate::Input>> {
        let mut Inputs = vec![];
        for i in 0..self.op.get_attr_int("N")? as i32 {
            Inputs.push(crate::Input {
                operation: &self.op,
                index: i,
            });
        }
        Ok(Inputs)
    }
}
impl From<ZipDatasetInst> for crate::Operation {
    fn from(inst: ZipDatasetInst) -> crate::Operation {
        inst.op
    }
}
/// Shorthand for `ZipDataset::new().build(input_datasets, scope)`.
pub fn zip_dataset<O0: ::std::convert::Into<crate::Output>>(
    input_datasets: O0,
    scope: &mut crate::Scope,
) -> crate::Result<crate::Operation> {
    ZipDataset::new().build(input_datasets, scope)
}