struct QuantizePass : public impl::QuantizePassBase<QuantizePass> {
 public:
  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(QuantizePass)

  // Constructor used by the PassRegistration and only used by test.
  explicit QuantizePass() { quant_specs.inference_type = tensorflow::DT_QINT8; }

  // Constructor used by manually creating the pass.
  explicit QuantizePass(const quant::QuantizationSpecs& quant_specs)

                                  quantfork::QuantizeCastOp>(ctx) {}
};

class QuantizePass : public impl::QuantizePassBase<QuantizePass> {
 public:
  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(QuantizePass)

  using impl::QuantizePassBase<QuantizePass>::QuantizePassBase;

  explicit QuantizePass(const bool enable_per_channel_quantized_weight) {

  }
};

// Applies quantization on the model in TF dialect.
class QuantizePass
    : public PassWrapper<QuantizePass, OperationPass<func::FuncOp>> {
 public:
  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(QuantizePass)

  // Constructor used by the PassRegistration and only used by test.
  explicit QuantizePass() {
    quant_specs_.inference_type = tensorflow::DT_QINT8;
  }

  }

 private:
  void runOnOperation() override;
};

void QuantizeCompositeFunctionsPass::runOnOperation() {
  MLIRContext& ctx = getContext();

  PassManager pm(&ctx);
  // Intermediate output from QuantizePass will have quantized ops
  // (XlaCallModuleOps) with quantized input and output types, which are not
  // allowed in the TF dialect.
  pm.enableVerifier(false);

  PrepareQuantizePassOptions options;

  bool use_fake_quant_num_bits = false;

  // Names of ops to block from quantization. Used in QuantizePass.
  // For dynamic range quantization, ops in blocklist are quantized in weight-
  // only manner.
  absl::flat_hash_set<std::string> ops_blocklist;

  // Names of locations to block from quantization. Used in QuantizePass.
  absl::flat_hash_set<std::string> nodes_blocklist;

  // TODO(b/265081639): When added PrepareQuantizeVariablesPass before adding
  // PrepareQuantizePass, an error occurs in certain model. It could fix it by
  // roll-back to run PrepareQuantizeVariablesPass, QuantizePass,
  // PostQuantizePass as suggested in cl/479634700. Need to figure out the
  // fundamental reason of the error, and (if needed) fix it without this
  // rollback.
  if (quant_specs.enable_mlir_variable_quantization) {

  let dependentDialects = [
      "mlir::stablehlo::StablehloDialect",
      "mlir::quant::QuantizationDialect",
      "mlir::quantfork::QuantizationForkDialect",
      "mlir::arith::ArithDialect",
  ];
}

def QuantizePass : Pass<"stablehlo-quantize", "mlir::ModuleOp"> {
  let summary = "Applies static-range quantization on ops by converting quantfork.qcast, quantfork.dcast, and float op into uniform quantized ops .";
  let options = [

      return true;
  }
  return false;
}

// Unwraps quantization parameters of PartitionedCall ops with quantized
// input/outputs that are created from QuantizePass.
class QuantizeFunctionPattern
    : public mlir::OpRewritePattern<TF::PartitionedCallOp> {
 public:
  explicit QuantizeFunctionPattern(MLIRContext* context,

      Option<"use_fake_quant_num_bits_", "use-fake-quant-num-bits",
             "bool", "false",
             "Use quantization calculated from fake quant attributes.">,
  ];
}

def QuantizePass : Pass<"tfl-quantize", "mlir::func::FuncOp"> {
  let summary = "Apply quantization on models in TensorFlow Lite dialect.";
  let constructor = "CreateDefaultQuantizePass()";

               ConvertTFDilatedConvOp<TF::DepthwiseConv2dNativeOp>>(ctx);

  patterns.add<RemoveIdentity>(ctx);
  TFL::populateWithGenerated(patterns);
  // TODO(fengliuai): Implement similar rule in the QuantizePass if the constant
  // folding hook of tfl.transpose and tfl.reshape are implemented.
  patterns.add<ReorderFakeQuantPattern<TF::ReshapeOp>,
               ReorderFakeQuantPattern<TF::TransposeOp>>(ctx);