def TFL_LogicalNotOp : TFL_Op<"logical_not", [
    Pure,
    SameOperandsAndResultShape]> {
  let summary = "Logical NOT operator";

  let description = [{
    Element-wise logical NOT operation.
  }];

  let arguments = (ins TFL_BoolTensor:$lhs);

  let results = (outs TFL_BoolTensor:$output);
}

def TFL_LogicalOrOp : TFL_Op<"logical_or", [Pure]> {
  let summary = "Logical OR operator";

  }];

  let assemblyFormat = [{
    $callee `(` $args `)` attr-dict `:` functional-type($args, results)
  }];
}

def TFR_CastOp : TFR_Op<"cast", [Pure]> {
  let description = [{
    The `cast` operation converts the operand with built-in tensor type to
    tfr.tensor type, or vice versa.

    Example:

    ```mlir

are in `[0,1]`.

`output[..., 0]` contains hue, `output[..., 1]` contains saturation, and
`output[..., 2]` contains value. All HSV values are in `[0,1]`. A hue of 0
corresponds to pure red, hue 1/3 is pure green, and 2/3 is pure blue.

Usage Example:

>>> blue_image = tf.stack([
...    tf.zeros([5,5]),
...    tf.zeros([5,5]),
...    tf.ones([5,5])],
...    axis=-1)

include "mlir/Interfaces/SideEffectInterfaces.td"
include "mlir/IR/OpAsmInterface.td"
include "mlir/IR/OpBase.td"
include "mlir/IR/SymbolInterfaces.td"

class TF_TensorListInitOp<string mnemonic> : TF_Op<mnemonic, [Pure]> {
  let results = (outs
    TF_VariantTensor:$handle
  );

  TF_DerivedOperandTypeAttr shape_type = TF_DerivedOperandTypeAttr<0>;

  let hasVerifier = 1;

  DerivedTypeAttr element_dtype = DerivedTypeAttr<

  );

  let assemblyFormat = "operands attr-dict `:` `(` type($in_ch) `)` `->` `(` type($out_ch) `,` type($results) `)`";
}

def ConstTensorProtoOp : FallbackAsync_Op<"const_tensor_proto",
    [Pure, CoreRT_TypedAttributeTrait,
     TFRT_CostFunctionInterface, TFRT_FixedCost<1>]> {
  let summary = "Create a tensorflow tensor from serialized tensor proto";

  let description = [{

// (where the operand and result type are not quantized) at all points where
// it is legal to use a quantized representation (but is not known to be
// acceptable).
def Quantization_QuantizeCastOp : Quantization_Op<"qcast", [Pure]> {
  let arguments = (ins quant_RealValueType:$arg);
  let results = (outs quant_RealValueType);
}

// A DequantizeCast op (dcast) represents the inverse of a qcast,

    I64ArrayAttr:$indices
  );

  let results = (outs
    Variadic<TFTensorType>:$results
  );

  let assemblyFormat = "attr-dict `:` type($results)";
}

def AwaitOp: TensorflowMlrt_Op<"await", [Pure]> {
  let summary = "Await a tensor from a !mlrt.future";

  let description = [{
    Await a tensor from a !mlrt.future.

    $future: A value of type !mlrt.future. The underlying value must be a tensorflow tensor.

            get() = objectType

        override val configuredType: DataTypeRef
            get() = returnValueType
    }

    @Serializable
    @SerialName("pure")
    data class DefaultPure(override val returnValueType: DataTypeRef) : Pure

    /** Implementations for [ConfigureBlockRequirement] */
    data object DefaultConfigureBlockRequirement {
        @Serializable
        @SerialName("notAllowed")

// (where the operand and result type are not quantized) at all points where
// it is legal to use a quantized representation (but is not known to be
// acceptable).
def quantfork_QuantizeCastOp : quantfork_Op<"qcast", [Pure]> {
  let arguments = (ins quant_RealValueType:$arg);
  let results = (outs quant_RealValueType);
}

// A DequantizeCast op (dcast) represents the inverse of a qcast,

// tf_mlrt.tf_await returns a tensorflow Tensor. It is a fake op that is only
// used during parallelization and has no runtime implementation.
def TFAwaitOp: TensorflowMlrt_Op<"tf_await", [Pure, TFRT_CostFunctionInterface, TFRT_FixedCost<1>]> {
  let summary = "Await a tensor from a !mlrt.future";

  let description = [{
    Await a tensor from a !mlrt.future.