};

inline std::unique_ptr<SavedModelAPI> SavedModelAPI::Load(
    const std::string& saved_model_path, const Runtime& runtime, Status* status,
    const std::unordered_set<std::string>* tags) {
  TF_SavedModel* saved_model = nullptr;

  if (tags == nullptr) {
    saved_model =
        TF_LoadSavedModel(saved_model_path.c_str(), runtime.GetTFEContext(),
                          status->GetTFStatus());
  } else {

    # saved the model
    test_model = TestModule()
    saved_model_path = '/tmp/test.saved_model'
    save_options = tf.saved_model.SaveOptions(save_debug_info=True)
    tf.saved_model.save(test_model, saved_model_path, options=save_options)

    # load the model and convert
    converter = tf.lite.TFLiteConverter.from_saved_model(saved_model_path)
    converter.convert()

# pylint: disable=line-too-long

                           exported_model, src_saved_model_path, tags,
                           signature_def_map);
  }

  std::optional<bool> RunCalibration(
      const absl::string_view saved_model_path,
      const std::vector<std::string>& signature_keys,
      const std::unordered_set<std::string>& tags,
      const bool force_graph_mode_calibration,

}

std::string ExperimentalConvertSavedModelToMlir(
    const std::string& saved_model_path, const std::string& exported_names_str,
    bool show_debug_info, TF_Status* status) {
  // Load the saved model into a SavedModelV2Bundle.

  tensorflow::SavedModelV2Bundle bundle;
  auto load_status =
      tensorflow::SavedModelV2Bundle::Load(saved_model_path, &bundle);
  if (!load_status.ok()) {

// Returns "/tensorflow/core/saved_model/write/path" cell, which contains
// the saved_model_path of the SM when it is exported.
monitoring::GaugeCell<std::string>& SavedModelWritePath();

// Returns "/tensorflow/core/saved_model/write/path_and_fingerprint" cell, which
// contains the path (saved_model_path) and fingerprint (concatenation of
// graph_def_program_hash, signature_def_hash, saved_object_graph_hash,

using tensorflow::experimental::cc::RuntimeBuilder;
using tensorflow::experimental::cc::SavedModelAPI;
using tensorflow::experimental::cc::Status;

constexpr char kTestData[] = "cc/saved_model/testdata";

std::string SavedModelPath(tensorflow::StringPiece saved_model_dir) {
  return tensorflow::io::JoinPath(tensorflow::testing::TensorFlowSrcRoot(),
                                  kTestData, saved_model_dir);
}

      tags: set[str],
      serialized_signature_def_map: dict[str, bytes],
  ) -> Optional[bool]: ...
  # LINT.ThenChange()

  # LINT.IfChange(run_calibration)
  def run_calibration(
      self,
      saved_model_path: str,
      signature_keys: list[str],
      tags: set[str],
      force_graph_mode_calibration: bool,
      # Value type: RepresentativeDatasetFile.
      representative_dataset_file_map_serialized: dict[str, bytes],

#include "tensorflow/core/platform/tstring.h"

namespace {

using tensorflow::tstring;

constexpr char kTestData[] = "cc/saved_model/testdata";
const char* kServeTag[] = {"serve"};

std::string SavedModelPath(tensorflow::StringPiece saved_model_dir) {
  return tensorflow::io::JoinPath(tensorflow::testing::TensorFlowSrcRoot(),
                                  kTestData, saved_model_dir);
}

          signature_def_map) const = 0;
  // LINT.ThenChange(
  //     pywrap_function_lib.pyi:save_exported_model,
  //     py_function_lib.py:save_exported_model,
  // )

  // Runs calibration on a model saved at `saved_model_path`. `exported_model`
  // should be the corresponding exported model resulting from the
  // pre-calibration step. `signature_keys` is a set of keys that identify a

        func=functools.partial(
            _run_calibration,
            saved_model_path,
            signature_keys,
            tags,
            force_graph_mode_calibration,
            dataset_file_map,
        ),
        error_msg=(
            f'Failed to run calibration on model "{saved_model_path}",'
            f' signature_keys: {signature_keys}, tags: {tags}.'
        ),
    )