const FlatbufferExportOptions& options,
                                       std::string* serialized_flatbuffer,
                                       bool serialize_stablehlo_ops = false);
}  // namespace tflite

extern llvm::cl::opt<bool> post_training_quantization;

// TF to stablehlo pass flags
extern llvm::cl::opt<bool> enable_stablehlo_conversion;

// Wether serialize stablehlo ops or not
extern llvm::cl::opt<bool> serialize_stablehlo_ops;

    const mlir::TFL::PassConfig& pass_config,
    const std::unordered_set<std::string>& saved_model_tags,
    llvm::StringRef saved_model_dir, SavedModelBundle* saved_model_bundle,
    std::string* result, bool serialize_stablehlo_ops = false,
    const quantization::PyFunctionLibrary* quantization_py_function_lib =
        nullptr);
}  // namespace tensorflow

    const mlir::TFL::PassConfig& pass_config,
    const std::unordered_set<std::string>& saved_model_tags,
    llvm::StringRef saved_model_dir, SavedModelBundle* saved_model_bundle,
    std::string* result, bool serialize_stablehlo_ops,
    const PyFunctionLibrary* quantization_py_function_lib) {
  // Explicitly disable dumping Op details on failures.
  module.getContext()->printOpOnDiagnostic(false);

  mlir::DialectRegistry registry;

    llvm::cl::desc("Convert \"tf.TensorList*\" ops to \"tfl.custom_op\""
                   "if they can all be supported."),
    llvm::cl::init(false));

// NOLINTNEXTLINE
opt<bool> serialize_stablehlo_ops(
    "serialize-stablehlo-ops",
    llvm::cl::desc("Wether serialize stablehlo ops or not"),
    llvm::cl::init(true));

// NOLINTNEXTLINE
opt<bool> reduce_type_precision(
    "reduce-type-precision",

  auto status = tensorflow::ConvertTFExecutorToTFLOrFlatbuffer(
      module.value().get(), output_mlir, toco_flags, pass_config, tags,
      /*saved_model_dir=*/"", bundle.get(), &result, serialize_stablehlo_ops);
  if (!status.ok()) {
    llvm::errs() << status.message() << '\n';
    return kTrFailure;
  }

  std::string error_msg;
  auto output = mlir::openOutputFile(output_file_name, &error_msg);

  auto status = ConvertTFExecutorToTFLOrFlatbuffer(
      module.get(), /*export_to_mlir=*/false, toco_flags, pass_config_copy,
      saved_model_tags, model_flags.saved_model_dir(), saved_model_bundle,
      result, /*serialize_stablehlo_ops=*/false, quantization_py_function_lib);
  if (toco_flags.has_dump_graphviz_dir()) {
    TF_RETURN_IF_ERROR(DumpOpGraphToFile(
        // rename once we enable the new converter feature flag.

                                       std::string* serialized_flatbuffer,
                                       bool serialize_stablehlo_ops) {
  auto maybe_translated = Translator::Translate(
      module, options.toco_flags, options.saved_model_tags,
      options.op_or_arg_name_mapper, options.metadata, serialize_stablehlo_ops,
      options.custom_option_alignment);
  if (!maybe_translated) return false;