StrAttr:$output_file_path,
    StrArrayAttr:$ids,
    I32ArrayAttr:$calibration_methods
  );

  TF_DerivedOperandTypeListAttr Tin = TF_DerivedOperandTypeListAttr<0>;
}

def TF_DumpTensorOp : TF_Op<"DumpTensor", []> {
  let summary = "Dump tensor proto.";

  let arguments = (ins
    Arg<TF_Tensor>:$input,

    StrAttr:$log_dir_path,
    StrAttr:$file_name,

  }];

  let arguments = (ins
    TFRT_ChainType:$in_ch,
    I64Attr:$num_args,
    StrAttr:$device,
    ArrayAttr:$op_attrs,
    // TODO(b/173025975): consider using DictionaryAttr after we support
    // BEF conversion for this type.
    ArrayAttr:$op_func_attrs,
    I64Attr:$op_key,
    StrAttr:$op_name
  );

  let results = (outs
    TFRT_ChainType:$out_ch
  );

          (variadic $inputs),
          ConstantStrAttr<StrAttr, "aten.gelu.default">, $attrs, $_, $_),
        (TFL_GeluOp $inputs, ConstBoolAttrFalse),
        [(IsStrCompositeAttribute<"approximate", "none"> $attrs)]>;

def LegalizeCompositeApproximateAtenGELU : Pat<
        (MHLO_CompositeOp:$composite
          (variadic $inputs),
          ConstantStrAttr<StrAttr, "aten.gelu.default">, $attrs, $_, $_),

  }];

  let arguments = (ins
    StrAttr:$node_def,
    I32Attr:$op_key
  );

  let assemblyFormat = "attr-dict";
}

def ConstOp: TensorflowMlrt_Op<"constop", []> {
  let summary = "The tf_mlrt ConstOp";

  let description = [{
    The ConstOp creates a constant tensorflow::Tensor from serialized proto.
  }];

  let arguments = (ins
    StrAttr:$tensor_proto
  );

  let results = (outs

  }];
  let arguments = (ins
    Variadic<TFTensorType>:$operands_and_static_shapes,
    DenseI32ArrayAttr:$constant_operand_indices,
    StrAttr:$metadata,
    StrAttr:$mlir_module,
    UI32Attr:$num_operands,
    DenseI32ArrayAttr:$operands_with_static_shape,
    StrAttr:$producer_name
  );

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

underlying graph, and executes each of the partitioned subgraphs as a function.
  }];

  let arguments = (ins
    Variadic<TF_Tensor>:$args,

    FlatSymbolRefAttr:$f,
    StrAttr:$config,
    StrAttr:$config_proto,
    StrAttr:$executor_type
  );

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

  TF_DerivedOperandTypeListAttr Tin = TF_DerivedOperandTypeListAttr<0>;

  IsCompositeAttribute<attr_name, BoolAttr, val>;

// Receives a composite DictionaryAttr as an argument and checks if has a
// StrAttr with the name `attr_name` and value `val`.
class IsStrCompositeAttribute <string attr_name, string val>:
  IsCompositeAttribute<attr_name, StrAttr, "\"" # val # "\"">;

  let summary = "Send a value to a host.";

  let description = [{
    Send the value to the given host with the given rendezvous key.
  }];

  let arguments = (ins
    AnyType:$value,
    StrAttr:$key,
    StrAttr:$dst_host
  );

  let results = (outs);

  let assemblyFormat = [{$value $key $dst_host attr-dict `:` type($value)}];
}

def TfDevice_ReceiveOp : TfDevice_Op<"receive", []> {

def LegalizeAvgPool2dComposite: Pat<
                    (MHLO_CompositeOp:$old_val
                    (variadic $a_input), 
                    ConstantStrAttr<StrAttr, "aten.avg_pool2d.default">, $attrs, $_, $_),
                    (TFL_TransposeOp 
                        (TFL_AveragePool2DOp 
                            /*input*/ (TFL_TransposeOp $a_input,

  }];
  let arguments = (ins
    Variadic<TF_Tensor>:$operands_and_static_shapes,
    DenseI32ArrayAttr:$constant_operand_indices,
    StrAttr:$metadata,
    StrAttr:$mlir_module,
    UI32Attr:$num_operands,
    DenseI32ArrayAttr:$operands_with_static_shape,
    StrAttr:$producer_name
  );

  let results = (outs
    TF_Tensor:$rendezvous_key_base,
    Variadic<TF_Tensor>:$results
  );