def ExperimentalMlirSparsifyModel(input_contents_txt_raw: object) -> object: ...
def FlatBufferToMlir(arg0: str, arg1: bool) -> str: ...
def RegisterCustomOpdefs(custom_opdefs_txt_raw: object) -> object: ...

  return _pywrap_converter_api.RetrieveCollectedErrors()


def wrapped_flat_buffer_file_to_mlir(model, input_is_filepath):
  """Wraps FlatBufferFileToMlir with lazy loader."""

  std::string error;
  auto loc =
      mlir::FileLineColLoc::get(context, input->getBufferIdentifier(), 0, 0);
  std::vector<std::string> inputs;
  std::vector<std::string> outputs;
  return tflite::FlatBufferToMlir(
      absl::string_view(input->getBufferStart(), input->getBufferSize()),
      context, loc, false, inputs, outputs, false);
}

}  // namespace

      mlir::FileLineColLoc::get(context, input_filename, /*line=*/0,
                                /*column=*/0);
  std::vector<std::string> inputs;
  std::vector<std::string> outputs;
  return tflite::FlatBufferToMlir(
      absl::string_view(buffer->getBufferStart(), buffer->getBufferSize()),
      context, loc, /*use_external_constant=*/false, inputs, outputs,
      experimental_prune_unreachable_nodes_unconditionally);
}

  std::string serialized_model(
      reinterpret_cast<const char*>(input_builder.GetBufferPointer()),
      input_builder.GetSize());

  OwningOpRef<mlir::ModuleOp> module = tflite::FlatBufferToMlir(
      serialized_model, &context, UnknownLoc::get(&context));
  if (!module) {
    LOG(ERROR) << "Couldn't import flatbuffer to MLIR.";
    return absl::InternalError("Couldn't import flatbuffer to MLIR.");
  }

        }
        return serialized_message_list;
      },
      R"pbdoc(
      Returns and clears the list of collected errors in ErrorCollector.
    )pbdoc");
  m.def(
      "FlatBufferToMlir",
      [](const std::string& model, bool input_is_filepath) {
        return tflite::FlatBufferFileToMlir(model, input_is_filepath);
      },
      R"pbdoc(
      Returns MLIR dump of the given TFLite model.

  MLIRContext context(registry);
  StatusScopedDiagnosticHandler statusHandler(&context,
                                              /*propagate=*/true);

  OwningOpRef<mlir::ModuleOp> module = tflite::FlatBufferToMlir(
      model_buffer, &context, UnknownLoc::get(&context));
  if (!module) {
    LOG(ERROR) << "Couldn't import flatbuffer to MLIR.";
    return kTfLiteError;
  }

  // Apply quantization passes.

  std::string serialized_model(
      reinterpret_cast<const char*>(input_builder.GetBufferPointer()),
      input_builder.GetSize());

  OwningOpRef<mlir::ModuleOp> module = tflite::FlatBufferToMlir(
      serialized_model, &context, UnknownLoc::get(&context));

  // Apply quantization passes.
  PassManager pm((*module)->getName(), OpPassManager::Nesting::Implicit);
  quant::QuantizationSpecs quant_specs;

                   ("Unable to load input file " + error).c_str());
      return;
    }

    auto buffer_view =
        std::string_view(buffer->getBufferStart(), buffer->getBufferSize());
    module = tflite::FlatBufferToMlir(
        buffer_view, &context, loc, use_external_constant, ordered_input_arrays,
        ordered_output_arrays);
    mlir::PassManager pm(&context, module.get()->getName().getStringRef(),

    to_delete_funcs.push_back(cond);
  });
  for (auto& func : to_delete_funcs) {
    func.erase();
  }
}
}  // namespace

OwningOpRef<mlir::ModuleOp> tflite::FlatBufferToMlir(
    absl::string_view buffer, MLIRContext* context, Location base_loc,
    bool use_external_constant,
    const std::vector<std::string>& ordered_input_arrays,