}
  const auto& any_assets = assets_it->second.any_list().value();
  for (const auto& any_asset : any_assets) {
    AssetFileDef asset_file_def;
    TF_RETURN_IF_ERROR(
        ParseAny(any_asset, &asset_file_def, "tensorflow.AssetFileDef"));
    asset_file_defs->push_back(asset_file_def);
  }
  return absl::OkStatus();
}

}  // namespace internal

  } else {
    return filename;
  }
}

AssetFileDef CreateAssetFileDef(const StringRef filename,
                                const StringRef tensor_name) {
  AssetFileDef asset_file_def{};
  asset_file_def.set_filename(MaybeStripAssetDirectoryPrefix(filename).str());

  tensorflow::TensorInfo tensor_info{};
  tensor_info.set_name(tensor_name.str());
  *asset_file_def.mutable_tensor_info() = tensor_info;

      }
    }
  )mlir");

  FailureOr<SmallVector<AssetFileDef>> asset_file_defs =
      ConvertAssetArgs(*module_op);

  EXPECT_TRUE(succeeded(asset_file_defs));
  EXPECT_THAT(*asset_file_defs, SizeIs(1));

  const AssetFileDef& asset_file_def = *asset_file_defs->begin();
  EXPECT_THAT(asset_file_def.filename(), Eq("file_0.txt"));
  EXPECT_THAT(asset_file_def.tensor_info().name(), Eq("arg_0:0"));

      }
    }
  )mlir");
  ASSERT_TRUE(module_op);

  AssetFileDef asset_file_def{};
  ASSERT_TRUE(
      TextFormat::ParseFromString(R"pb(filename: "vocab_file.txt",
                                       tensor_info { name: "arg_0:0" })pb",
                                  &asset_file_def));
  const std::vector<AssetFileDef> asset_file_defs = {asset_file_def};

  const absl::StatusOr<ExportedModel> exported_model =

  exported_model.mutable_function_aliases()->insert(function_aliases.begin(),
                                                    function_aliases.end());

  for (const AssetFileDef& asset_file_def : asset_file_defs) {
    *exported_model.mutable_asset_file_defs()->Add() = asset_file_def;
  }

  if (saver_def != std::nullopt) {
    *exported_model.mutable_saver_def() = *std::move(saver_def);
  }

  return exported_model;
}

        signature_def_map, ops.get_default_graph()
    )

    # Add `AssetFileDef`s to the collection so that correct values are fed to
    # the tensors that accept asset file paths.
    for asset_file_def in asset_file_defs:
      asset_any_proto = Any()
      asset_any_proto.Pack(asset_file_def)
      ops.add_to_collection(
          saved_model_constants.ASSETS_KEY,
          asset_any_proto,

                              const std::vector<AssetFileDef>& asset_file_defs,
                              std::vector<std::pair<string, Tensor>>* inputs) {
  if (asset_file_defs.empty()) {
    return;
  }
  for (auto& asset_file_def : asset_file_defs) {
    Tensor assets_file_path_tensor = CreateStringTensor(io::JoinPath(
        export_dir, kSavedModelAssetsDirectory, asset_file_def.filename()));
    inputs->push_back(

    const absl::flat_hash_map<std::string, std::string>& function_aliases,
    const std::vector<tensorflow::AssetFileDef>& asset_file_defs);

// Sets up and runs the passes for exporting `module_op`. The behavior of the
// exporting passes is controlled by `export_opts`. Returns `AssetFileDef`s that
// associate the input arguments of @main and the asset file names. Asset file

Status GetInitOp(const string& export_dir, const MetaGraphDef& meta_graph_def,
                 string* init_op_name);

Status GetAssetFileDefs(const MetaGraphDef& meta_graph_def,
                        std::vector<AssetFileDef>* asset_file_defs);

}  // namespace internal
}  // namespace tensorflow

  TF_ASSIGN_OR_RETURN(const SmallVector<AssetFileDef> asset_file_defs,
                      RunExportPasses(export_opts, *ctx_, *cloned_module_ref));

  TF_ASSIGN_OR_RETURN(ExportedModel exported_model,
                      ConvertMlirModuleToExportedModel(
                          *cloned_module_ref, checkpoint_dir, function_aliases_,
                          {asset_file_defs.begin(), asset_file_defs.end()}));