class TFRDecomposeContext {
 public:
  // The entry function to get a decompose context. All the required passes have
  // been initialized.
  static absl::StatusOr<std::unique_ptr<TFRDecomposeContext>> Get(
      mlir::MLIRContext* mlir_ctx);

  // Constructor of the decompose context. To share the decompose library, the
  // whole decompose TFR function library is loaded.

namespace tensorflow {

// Create a module pass that will execute the given TF GraphOptimization passes
// in sequence.
// Pass requires that the module ran on is convertible to TF Graph.
std::unique_ptr<mlir::OperationPass<mlir::ModuleOp>>
CreateTensorFlowGraphOptimizationPass(
    std::vector<tensorflow::GraphOptimizationPass*> tf_passes);

// Same as above but pass names instead of the passes provided. The registered

  return OkStatus();
}

class PluggableProfiler : public tensorflow::profiler::ProfilerInterface {
 public:
  // The caller must have validated profiler_fns and profiler.
  static std::unique_ptr<tensorflow::profiler::ProfilerInterface>
  CreatePluggableProfiler(const ProfileOptions& options, TP_Profiler profiler,
                          TP_ProfilerFns profiler_fns) {
    if (options.device_tracer_level() == 0) {

 public:
  DeviceCompilerClient() = default;
  virtual ~DeviceCompilerClient() = default;

  // Compiles `result` (HLO) to an `ExecutableType` using `ClientType` and
  // returns it.
  virtual StatusOr<std::unique_ptr<ExecutableType>> BuildExecutable(
      const XlaCompiler::Options& options,
      const XlaCompiler::CompilationResult& result) = 0;

  // Serializes an available `executable` to string using `ClientType` and

  void UseOriginalFunctionNames(NodeDef& node_def);

  Status AddEdge(Operation* inst);

  absl::StatusOr<std::unique_ptr<NodeDef>> GetArgumentNode(
      BlockArgument arg, unsigned index, llvm::StringRef name);
  absl::StatusOr<std::unique_ptr<NodeDef>> GetReturnNode(FuncOp function,
                                                         Value operand,

  void UseOriginalFunctionNames(NodeDef& node_def);

  Status AddEdge(Operation* inst);

  absl::StatusOr<std::unique_ptr<NodeDef>> GetArgumentNode(
      BlockArgument arg, unsigned index, llvm::StringRef name);
  absl::StatusOr<std::unique_ptr<NodeDef>> GetReturnNode(FuncOp function,
                                                         Value operand,

      signalPassFailure();
  }
};

}  // namespace
}  // namespace tf_saved_model

namespace tf_test {

std::unique_ptr<OperationPass<ModuleOp>> CreateLiftVariablesTestPass() {
  return std::make_unique<tf_saved_model::LiftVariablesTestPass>();
}

std::unique_ptr<OperationPass<ModuleOp>>
CreateLiftVariablesInvalidSessionTestPass() {
  return std::make_unique<

      }
    });
  }
};
}  // namespace

std::unique_ptr<OperationPass<func::FuncOp>> CreateSimpleTFDeviceAssignmentPass(
    llvm::StringRef default_device) {
  return std::make_unique<SimpleTFDeviceAssignmentPass>(default_device);
}

std::unique_ptr<OperationPass<func::FuncOp>>
CreateTFDeviceAssignmentByFuncAttrPass() {

#include "tensorflow/core/lib/llvm_rtti/llvm_rtti.h"
#include "tensorflow/core/platform/errors.h"

namespace tensorflow {

AbstractContext* BuildFunction(const char* fn_name) {
  std::unique_ptr<TF_Status, decltype(&TF_DeleteStatus)> status(
      TF_NewStatus(), TF_DeleteStatus);
  TF_ExecutionContext* graph_ctx = TF_CreateFunction(fn_name, status.get());
  return unwrap(graph_ctx);
}

// device memory. It also owns the PjRtBuffer.
//
// TODO(b/289001822): Create a unit test to cover this function.
absl::StatusOr<Tensor> MakeTensorFromPjRtBuffer(
    DataType dtype, const TensorShape& shape,
    std::unique_ptr<xla::PjRtBuffer> pjrt_buffer);

// For TensorFlow internal use only.
class PjRtTensorBufferUtil {
 public:
  // Takes the device memory pointer from the PjRtBuffer and create a