*/

package common

import (
	"fmt"
	"reflect"
	"sync"
	"time"

	"github.com/google/cel-go/common/types"
	"github.com/google/cel-go/common/types/ref"
	"github.com/google/cel-go/common/types/traits"

	"k8s.io/kube-openapi/pkg/validation/strfmt"

	"k8s.io/apimachinery/pkg/api/equality"
	"k8s.io/apiserver/pkg/cel"
)

// UnstructuredToVal converts a Kubernetes unstructured data element to a CEL Val.

  let name = "gpurt";

  let description = [{
    The TFRT GPU Dialect.
  }];

  let cppNamespace = "::tfrt::gpu";
}

class Gpu_Op<string mnemonic, list<Trait> traits = []> :
    Op<TFRT_GPU_Dialect, mnemonic, traits> {
}

// TODO(b/260267885): We may add a device argument when we want to support
// GPU MIG.
def TransferToDeviceOp: Gpu_Op<"transfer_to_device"> {

    /**
     * Test framework specific configuration for the build script.
     *
     * These values will be provided by test framework traits that can be attached to any test class.  As such, we use an interface
     * to ensure type safety and avoid decoupling of these methods in the trait classes.  The trait classes simply have to provide
     * an implementation of this interface specific to the test framework.
     */

// TensorFlow op definitions
//===----------------------------------------------------------------------===//

class TF_Op<string mnemonic, list<Trait> traits = []> :
    Op<TensorFlowDialect, mnemonic, traits>;

//===----------------------------------------------------------------------===//
// TensorFlow attribute definitions

		return apiservercel.StringType
	case cel.TimestampType:
		return apiservercel.TimestampType
	case cel.UintType:
		return apiservercel.UintType
	default:
		if celType.HasTrait(traits.ContainerType) && celType.HasTrait(traits.IndexerType) {
			parameters := celType.Parameters()
			switch len(parameters) {
			case 1:
				elemType := convertCelTypeToDeclType(parameters[0])
				return apiservercel.NewListType(elemType, -1)

#else
#define MLRT_OPS

include "mlir/Interfaces/SideEffectInterfaces.td"
include "tensorflow/compiler/mlir/tfrt/ir/mlrt/mlrt_dialect.td"

class Mlrt_Op<string mnemonic, list<Trait> traits = []> :
    Op<Mlrt_Dialect, mnemonic, !listconcat(traits, [IsolatedFromAbove])> {
}

def CondOp: Mlrt_Op<"cond", []> {
  let summary = "mlrt.cond op";

  let description = [{

//===----------------------------------------------------------------------===//

// Base class for the operation in this dialect.
class RuntimeFallbackDialect_Op<string mnemonic, list<Trait> traits = []> :
    Op<RuntimeFallback_Dialect, mnemonic, traits> { }

def InitEagerContextOp : RuntimeFallbackDialect_Op<"init_eager_context"> {
  let summary = "eager context initialization operation";
  let description = [{

#include "mlir/IR/OpImplementation.h"  // from @llvm-project
#include "mlir/Interfaces/InferTypeOpInterface.h"  // from @llvm-project
#include "mlir/Interfaces/SideEffectInterfaces.h"  // from @llvm-project
#include "tfrt/core_runtime/opdefs/traits.h"  // from @tf_runtime
#include "tfrt/tensor/opdefs/tensor.h"  // from @tf_runtime

using namespace mlir;  // NOLINT

namespace tfrt {
namespace fallback_sync {

// Dialect for fallback operations.

limitations under the License.
*/

package common

import (
	"fmt"
	"reflect"

	"github.com/google/cel-go/common/types"
	"github.com/google/cel-go/common/types/ref"
	"github.com/google/cel-go/common/types/traits"
)

// ObjectVal is the CEL Val for an object that is constructed via the object
// construction syntax.
type ObjectVal struct {
	typeRef TypeRef
	fields  map[string]ref.Val
}

#define TENSORFLOW_COMPILER_MLIR_QUANTIZATION_TENSORFLOW_OPS_TF_QUANTIZE_OP_H_

#include <optional>

#include "mlir/Dialect/Func/IR/FuncOps.h"  // from @llvm-project
#include "mlir/Dialect/Traits.h"  // from @llvm-project
#include "tensorflow/compiler/mlir/quantization/tensorflow/quantization_options.pb.h"
#include "tensorflow/compiler/mlir/tensorflow/ir/tf_ops.h"

namespace mlir {
namespace quant {