// Transforms the given module to be suitable for export to TensorFlow GraphDef
// and then exports all functions to the given library.
Status PrepareAndExportToLibrary(mlir::ModuleOp module,
                                 FunctionLibraryDefinition* flib_def) {
  // Pass pipeline is defined here instead of leveraging the phase one export
  // pipeline because only the functional to executor dialect conversion and

		// The Dynatrace sampler can re-use the same Dynatrace service/cluster/headers
		// as configured for the HTTP Exporter. In this case users
		// can achieve a much smaller/simpler config in Istio.

		// Re-use the Dynatrace API Host from the OTLP HTTP exporter
		otlpHTTPService := otelProvider.GetHttp()
		if otlpHTTPService == nil {

      },
      R"pbdoc(
        Converts a TensorFlow SavedModel into StableHLO bytecode.

        * input-path: The path to the input TensorFlow SavedModel.
        * exported-model-signatures: Comma-separated list of exported model
          signatures to convert.
        * tag_names: Comma-separated list of tags for loading SavedModel.
        * input-arg-shapes: A string representation of input argument shapes for

    --input-path=/path/to/model \
    [--exported-model-signatures=signature1,signature2] \
    [--tag-names=tag1,tag2] \
    [--input-arg-shapes-str=arg-name:shape,...] \
    [--e] \
    [--output-filename=/path/to/output.mlir]
```

* `--input-path`: The path to the input TensorFlow SavedModel or MLIR module
  with .mlir extension.
* `--exported-model-signatures`: Comma-separated list of exported model

    TF_ASSIGN_OR_RETURN(
        const auto representative_dataset_file_map,
        CreateRepresentativeDatasetFileMap(dataset_config_vector));

    // Run calibration on the exported model.
    if (py_function_lib_->RunCalibration(
            calibration_saved_model_dir, signature_keys_, tags_,
            /*force_graph_mode_calibration=*/true,

        "expresses argument shapes [1,2], [] and [1,?]"),
    llvm::cl::Optional, llvm::cl::init(""));

// NOLINTNEXTLINE
opt<std::string> exported_model_signatures(
    "exported-model-signatures",
    llvm::cl::desc(
        "Comma-separated list of exported model signatures to convert"),
    llvm::cl::Optional, llvm::cl::init("serving_default"));

// NOLINTNEXTLINE
opt<std::string> tag_names(
    "tags",

	}
	scope := pkg.Scope()

	// 2. package-level object?
	if scope.Lookup(obj.Name()) == obj {
		// Only exported objects (and non-exported types) have a path.
		// Non-exported types may be referenced by other objects.
		if _, ok := obj.(*types.TypeName); !ok && !obj.Exported() {
			return "", fmt.Errorf("no path for non-exported %v", obj)
		}
		return Path(obj.Name()), nil
	}

	// 3. Not a package-level object.

                    it.name
                    it.arguments
                }
                withGradleProject(gradleProject)
                classpath.collect {
                    [it.exported, it.file, it.gradleModuleVersion.group, it.gradleModuleVersion.name, it.gradleModuleVersion.version, it.javadoc, it.source]
                }
                javaSourceSettings?.jdk?.javaHome

        EclipseClasspathContainer container = project.classpathContainers.find { it.path == 'whenMergedContainerPath' }

        then:
        container != null
        container.exported == false
    }

    def "Classpath container can be configured"() {
        buildFile <<
        """apply plugin: 'java'
           apply plugin: 'eclipse'
           eclipse {
               classpath {

}

// All published variables.
var vars Map

// Publish declares a named exported variable. This should be called from a
// package's init function when it creates its Vars. If the name is already
// registered then this will log.Panic.
func Publish(name string, v Var) {
	if _, dup := vars.m.LoadOrStore(name, v); dup {
		log.Panicln("Reuse of exported var name:", name)
	}
	vars.keysMu.Lock()
	defer vars.keysMu.Unlock()