// Use quant_specs.ops_blocklist and quant_specs.nodes_blocklist if possible
// as they are now structure variables of QuantizationSpecs.
std::unique_ptr<OperationPass<func::FuncOp>> CreateQuantizePass(
    const quant::QuantizationSpecs& quant_specs,
    const absl::flat_hash_set<std::string>& ops_blocklist = {},
    const absl::flat_hash_set<std::string>& nodes_blocklist = {});

    signature_def_map_serialized[key] = signature_def.SerializeToString()

  return signature_def_map_serialized


def _has_quantization_method(
    quantization_specs: qc.QuantizationSpecs, method: str
) -> bool:
  """Returns whether a given QuantizationSpecs has the given quantization method."""
  for spec in quantization_specs.specs:
    if spec.method.HasField(method):
      return True
  return False

                              const absl::string_view max_values,
                              const absl::string_view inference_type,
                              QuantizationSpecs* quant_specs) {
  const std::vector<std::string> input_nodes = absl::StrSplit(node_names, ',');
  std::vector<std::optional<double>> node_mins;
  if (!min_values.empty()) {

    quant_specs_.enable_mlir_dynamic_range_quantizer = true;
  }

  // Constructor used by manually creating the pass.
  explicit PrepareDynamicRangeQuantizePass(
      const quant::QuantizationSpecs& quant_specs)
      : quant_specs_(quant_specs) {
    enable_dynamic_range_per_channel_quantization_ =
        !quant_specs_.disable_per_channel;
    enable_dynamic_range_per_channel_quantization_for_dense_layers_ =

#include "mlir/Pass/Pass.h"  // from @llvm-project  // IWYU pragma: keep

namespace mlir::quant::stablehlo::testing {

// Identifies predefined `QuantizationSpecs` for
// `TestLiftQuantizableSpotsAsFunctionsWithQuantizationSpecsPass`. The pass
// option argument is specified in line comments for each enum value.
enum class TestQuantizationSpecs {

// input and output types by unwrapping quantization parameters.
std::unique_ptr<OperationPass<func::FuncOp>> CreateQuantizePass();

// Overloading of CreateQuantizePass which takes QuantizationSpecs.
std::unique_ptr<OperationPass<func::FuncOp>> CreateQuantizePass(
    QuantizationSpecs quant_specs,
    tensorflow::quantization::OpSet target_opset);

// Creates an instance of the PrepareQuantize pass, which will perform similar

namespace mlir {
namespace TFL {

// A config that controls which passes get run as part TFLite converter.
struct PassConfig {
  explicit PassConfig(quant::QuantizationSpecs specs)
      : quant_specs(std::move(specs)) {}

  // If `emit_builtin_tflite_ops` is true, TF Lite legalization passes will be
  // added, which produces TF Lite ops.
  bool emit_builtin_tflite_ops = true;

  explicit PrepareQuantizePass() {
    quant_specs_.inference_type = tensorflow::DT_QINT8;
  }

  // Constructor used by manually creating the pass.
  explicit PrepareQuantizePass(const QuantizationSpecs& quant_specs,
                               QuantMethod quantization_method)
      : quant_specs_(quant_specs) {
    quant_specs_.inference_type = tensorflow::DT_QINT8;

// datasets are required for static-range PTQ to retrieve quantization
// statistics via calibration.
//
// This preset is equivalent to the following `QuantizationSpecs`:
//
// ```
// specs {matcher {function_name {regex: ".*"}} method {static_range_ptq {}}}
// specs {
//   matcher {function_name {regex: "composite_conv.*"}}
//   method {static_range_ptq {

using CustomOpMap = std::unordered_map<std::string, CustomOpInfo>;
enum CustomOpUpdateOptions { kInputIndices, kWeightOnly, kNoSideEffect };
enum class QDQConversionMode { kQDQNone, kQDQStatic, kQDQDynamic };

struct QuantizationSpecs {
  // Which function this node quant specifications belong to.
  std::string target_func = "main";

  // Whether to trigger quantization passses for post-training quantization.