virtual bool GetBool(absl::string_view attr_name, bool* result) const = 0;
  virtual bool GetType(absl::string_view attr_name, DataType* result) const = 0;
  virtual Status GetTypeList(
      absl::string_view attr_name,
      absl::InlinedVector<DataType, 4>* type_list) const = 0;

 private:
  const AbstractOpAttrsKind kind_;
};

}  // namespace tensorflow

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

namespace tensorflow {
namespace internal {

Status CreateUninitializedResourceVariable(ImmediateExecutionContext* ctx,
                                           DataType dtype, TensorShape shape,
                                           const char* raw_device_name,
                                           ImmediateTensorHandlePtr* handle) {
  ImmediateOpPtr varhandle_op(ctx->CreateOperation());

@ToolingModelContract(subTypes = [
    DataTypeRef.Type::class,
    DataTypeRef.Name::class
])
sealed interface DataTypeRef : Serializable {
    interface Type : DataTypeRef {
        val dataType: DataType
    }

    interface Name : DataTypeRef {
        val fqName: FqName
    }

        val topLevelReceiverName = topLevelReceiver.fqName

        return DefaultAnalysisSchema(
            dataTypes.single { it.name == topLevelReceiverName },
            dataTypes.associateBy { it.name },
            extFunctions,
            extObjects,
            defaultImports.toSet()
        )
    }

    private
    val KClass<*>.fqName

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

namespace tensorflow {

Variable::Variable(ImmediateExecutionContext* ctx, DataType dtype,
                   TensorShape shape, absl::optional<std::string> name,
                   ImmediateTensorHandlePtr handle)
    : TensorHandleConvertible(std::move(handle)),

namespace tensorflow {
namespace ops {

// Creates a handle to a Variable resource.
Status VarHandleOp(AbstractContext* ctx, AbstractTensorHandle** resource,
                   DataType dtype, const PartialTensorShape shape,
                   const char* container = "", const char* shared_name = "",
                   absl::Span<string const> allowed_devices = {},
                   const char* name = nullptr,

// Convert the scalar type of a TFLite tensor to the corresponding
// Tensorflow type
tensorflow::DataType TflTypeToTfType(tflite::TensorType type);

// Convert the Tensorflow scalar type to the corresponding TFLite type
absl::StatusOr<tflite::TensorType> TfTypeToTflType(tensorflow::DataType type);

// Returns element type from attribute Type 'type_attr'.
mlir::Type GetShapeStrippedType(mlir::TypeAttr type_attr);

#include "llvm/Support/raw_ostream.h"
#include "tensorflow/core/framework/types.pb.h"

// Returns whether the given dtype is a quantization type in TensorFlow.
static bool IsQuantizationType(tensorflow::DataType dtype) {
  switch (dtype) {
    case tensorflow::DT_QINT8:
    case tensorflow::DT_QUINT8:
    case tensorflow::DT_QINT16:
    case tensorflow::DT_QUINT16:
    case tensorflow::DT_QINT32:
      return true;

  EXPECT_TRUE(n->IsConstant());
  Tensor tensor;
  TF_EXPECT_OK(GetNodeAttr(n->attrs(), "value", &tensor));
  DataType dtype;
  TF_EXPECT_OK(GetNodeAttr(n->attrs(), "dtype", &dtype));
  EXPECT_EQ(tensor.dtype(), dtype);
  test::ExpectTensorEqual<T>(tensor, test::AsTensor(values, shape));
}

void ExpectTypeAndShape(const Node* n, DataType expected_dtype,
                        TensorShape expected_shape) {
  EXPECT_TRUE(n->IsConstant());

// 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: