subgraph_index = 0;
  // Build SignatureDefs for the tf.entry_function based func ops.
  for (auto fn : entry_functions) {
    auto signature_defs = BuildSignaturedef(
        fn, saved_model_tags_.empty() ? "" : *saved_model_tags_.begin(),
        subgraph_index, name_mapper_);
    for (const auto& signature_def : signature_defs) {
      signature_defs_vec.push_back(signature_def);
    }

  }

  // Write MLIR Stablehlo dialect into FlatBuffer
  OpOrArgLocNameMapper op_or_arg_name_mapper;
  tflite::FlatbufferExportOptions options;
  options.toco_flags = toco_flags;
  options.saved_model_tags = saved_model_tags;
  options.op_or_arg_name_mapper = &op_or_arg_name_mapper;
  options.metadata[tflite::kModelUseStablehloTensorKey] = "true";
  if (!tflite::MlirToFlatBufferTranslateFunction(module, options, result,

// because quantization requires exporting the intermediate `ModuleOp` back to
// SavedModel for calibration. Similarly, `saved_model_dir` is required to
// access the assets of the original model. `saved_model_tags` uniquely
// identifies the `MetaGraphDef`. `quantization_config` determines the behavior
// of StableHLO Quantizer. `quantization_py_function_lib` contains python

  ASSERT_THAT(tmp_saved_model_dir, IsOk());

  QuantizationConfig config;
  const absl::StatusOr<mlir::ModuleOp> quantized_module_op = RunQuantization(
      /*saved_model_bundle=*/nullptr, *tmp_saved_model_dir,
      /*saved_model_tags=*/{}, config,
      /*quantization_py_function_lib=*/nullptr, /*module_op=*/{});
  EXPECT_THAT(
      quantized_module_op,
      StatusIs(absl::StatusCode::kInvalidArgument,

  TF_RETURN_IF_ERROR(internal::RegisterAllCustomOps(toco_flags));

  auto& saved_model_tags = model_flags.saved_model_tags();
  auto& saved_model_exported_names = model_flags.saved_model_exported_names();
  std::unordered_set<std::string> tags(saved_model_tags.begin(),
                                       saved_model_tags.end());
  auto exported_names_in_vector = std::vector<std::string>(

}

}  // namespace

absl::StatusOr<mlir::ModuleOp> RunQuantization(
    const SavedModelBundle* saved_model_bundle,
    const absl::string_view saved_model_dir,
    const std::unordered_set<std::string>& saved_model_tags,
    const QuantizationConfig& quantization_config,
    const PyFunctionLibrary* quantization_py_function_lib,
    mlir::ModuleOp module_op) {
  if (saved_model_bundle == nullptr) {
    return absl::InvalidArgumentError(

    const toco::ModelFlags& model_flags, toco::TocoFlags& toco_flags,
    mlir::OwningOpRef<mlir::ModuleOp> module,
    const mlir::TFL::PassConfig& pass_config,
    const std::unordered_set<std::string>& saved_model_tags, string* result,
    SavedModelBundle* saved_model_bundle,
    const quantization::PyFunctionLibrary* quantization_py_function_lib);

// Give a warning for any unused flags that have been specified.

  // std::set<> select_user_tf_ops -> toco_flags.select_user_tf_ops()
  toco::TocoFlags toco_flags;
  // When exporting from SavedModel, this will have the requested tags.
  std::unordered_set<std::string> saved_model_tags;
  // Metadata key/value pairs to write to the flatbuffer.
  std::map<std::string, std::string> metadata;
  // OpOrArgNameMapper to convert location of the op to name in flatbuffer.

                   "representation without any graph transformation"),
    llvm::cl::value_desc("dir"));

// NOLINTNEXTLINE
static llvm::cl::opt<std::string> saved_model_tags(
    "tf-savedmodel-tags",
    llvm::cl::desc("Tags used to indicate which MetaGraphDef to import, "
                   "separated by ','"),
    llvm::cl::init("serve"));

// NOLINTNEXTLINE

  // quantization_py_function_lib is set to nullptr.
  return internal::ConvertMLIRToTFLiteFlatBuffer(
      model_flags, toco_flags, std::move(module), pass_config,
      /*saved_model_tags=*/{}, result, /*saved_model_bundle=*/nullptr,
      /*quantization_py_function_lib=*/nullptr);
}