class LegalizeHloToTfLitePass
    : public impl::LegalizeHloToTfLitePassBase<LegalizeHloToTfLitePass> {
 public:
  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(LegalizeHloToTfLitePass);

  void runOnOperation() override;
};

class ConvertReduceOpToTFLiteArgmax
    : public ConvertReduceOpToArgMinMax<TFL::ReduceMaxOp, TFL::ArgMaxOp,
                                        TFL::ReduceAnyOp, true> {
 public:

#include "tensorflow/compiler/mlir/tensorflow/transforms/test_passes.h.inc"

struct FreezeVariableTestPass
    : public impl::FreezeVariablesTestPassBase<FreezeVariableTestPass> {
  void runOnOperation() override {
    TF::test_util::FakeSession session;
    if (tf_saved_model::FreezeVariables(getOperation(), &session).failed())
      signalPassFailure();
  }
};
}  // namespace

#include "tensorflow/compiler/mlir/tensorflow/transforms/tf_passes.h.inc"

class VerifySuitableForExportPass
    : public impl::VerifySuitableForExportPassBase<
          VerifySuitableForExportPass> {
 public:
  void runOnOperation() override {
    if (failed(tensorflow::VerifyExportSuitable(getOperation())))
      return signalPassFailure();
  }
};

}  // namespace

    // before feeding them to the model and convert them back to floating point
    // (i.e. dequantize) as the output.
    this->emit_quant_adaptor_ops_ = emit_quant_adaptor_ops;
  }

  void runOnOperation() override;

 private:
  quant::CustomOpMap custom_op_map_;
};

// Cleans up unnecessary QDQ pattern for input/output ops.
class PostQuantizeRemoveQDQPass

class PostQuantizePass : public impl::PostQuantizePassBase<PostQuantizePass> {
 public:
  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(PostQuantizePass)

  explicit PostQuantizePass() = default;

 private:
  void runOnOperation() override;
};

// TODO: b/305815328 - Consider preserving leading and trailing QDQs for
// ModifyIONodesPass in TFLite use cases.
// Removes the back-to-back quantize and dequantize ops with volatile attribute.

      const std::function<bool(Operation *)> &partition = IsFlexDelegate)
      : partition_(partition) {}

  void runOnOperation() override;

 private:
  const std::function<bool(Operation *)> partition_;
};

void PartitionedTopologicalSortPass::runOnOperation() {
  func::FuncOp func = getOperation();
  if (!PartitionedTopologicalSort(func, &func.getBody().front(), partition_)) {

struct TPUUpdateEmbeddingEnqueueOpInputsPass
    : public impl::TPUUpdateEmbeddingEnqueueOpInputsPassBase<
          TPUUpdateEmbeddingEnqueueOpInputsPass> {
  void runOnOperation() override;
};

// Extracts `_tpu_embedding_layer` attribute from TPU embedding ops and
// clear the attribute from the operation. This ensures that future optimization

class ConvertReadonlyReferenceVariablesToResourceVariablesPass
    : public impl::ConvertReadonlyReferenceVariablesToResourceVariablesPassBase<
          ConvertReadonlyReferenceVariablesToResourceVariablesPass> {
  void runOnOperation() override;
};

// Parse node name from "_class" or "shared_name" attributes.
StringRef GetNodeNameFromClassAttrOrSharedNameAttr(Operation *op) {

struct SplitMergedOperandsPass
    : public impl::SplitMergedOperandsPassBase<SplitMergedOperandsPass> {
  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(SplitMergedOperandsPass)

  void runOnOperation() override;
};

LogicalResult DuplicateValueIfNeeded(Operation* op,
                                     llvm::DenseSet<Value>* values,
                                     OpBuilder* builder) {

// handling for `tf_device.parallel_execute`.
struct TPUParallelExecuteSinkResourceWrite
    : public impl::TPUParallelExecuteSinkResourceWritePassBase<
          TPUParallelExecuteSinkResourceWrite> {
  void runOnOperation() override;
};

// Finds an AssignVariableOp that can be moved into the parallel_execute region.
// These AssignVariableOps must be the only consumer of the respective