}
  };
  std::unique_ptr<TFE_ContextOptions, TFEContextOptionsDeleter> options_;
};

inline RuntimeBuilder& RuntimeBuilder::SetUseTFRT(bool use_tfrt) {
  TFE_ContextOptionsSetTfrt(options_.get(), use_tfrt);
  return *this;
}

inline std::unique_ptr<Runtime> RuntimeBuilder::Build(Status* status) {
  TFE_Context* result = TFE_NewContext(options_.get(), status->GetTFStatus());
  if (!status->ok()) {
    return nullptr;
  }

 public:
  // Options for configuring the importer.
  struct Options {
    std::string file_name;
    // Whether the input file is an MLIR not tflite file.
    bool input_mlir = false;
  };

  explicit TfLiteImporter(const Options& options) : options_(options) {}

  absl::StatusOr<mlir::OwningOpRef<mlir::ModuleOp>> Import() override;

 private:
  Options options_;
  mlir::MLIRContext context_;

      source_mgr_, &context_);
  return ImportFlatbufferOrMlir(
      options_.file_name, options_.input_mlir,
      /*experimental_prune_unreachable_nodes_unconditionally=*/true,
      &source_mgr_, &context_);
}

//////////// Exporter ////////////
absl::Status TfLiteExporter::Export(mlir::ModuleOp module) {
  // return absl::OkStatus();
  if (options_.export_runtime_metadata) {
    // Run the cost model for each device/op.

  mlir::PassManager pm((*module)->getName(),
                       mlir::OpPassManager::Nesting::Implicit);
  AddTACPass(&pm, options_.hardware_backends);
  if (!debug_mode) {
    AddExportTFLPass(&pm, options_.enable_inliner);
  }

  mlir::StatusScopedDiagnosticHandler statusHandler(module->getContext(),
                                                    /*propagate=*/true);

  virtual ~TacModule() = default;

  explicit TacModule(const Options& options) : options_(options) {}

  void SetImporter(std::unique_ptr<TacImporter> importer) {
    importer_ = std::move(importer);
  }

  void SetExporter(std::unique_ptr<TacExporter> exporter) {
    exporter_ = std::move(exporter);
  }

  // Returns pointer to the TargetHardware that is identified by 'hardware_name'

image::ci-systems/teamcity-step-added.png[]

Click _Edit_, on the page that opens click _Advanced options_.
Using the Wrapper to execute the build is considered good practice with Gradle,
and on automatic detection this option is selected by default.
We’ll want to generate a build scan,
so we’ll enter the `--scan` option in _Additional Gradle command line parameters_ field.

image::ci-systems/teamcity-scan.png[]

	Revision           string
	MeshConfigFile     string
	NetworksConfigFile string
	RegistryOptions    RegistryOptions
	CtrlZOptions       *ctrlz.Options
	KeepaliveOptions   *keepalive.Options
	ShutdownDuration   time.Duration
	JwtRule            string
}

// DiscoveryServerOptions contains options for create a new discovery server instance.
type DiscoveryServerOptions struct {

	retval := &cobra.Command{
		Use:   "options",
		Short: "Displays istioctl global options",
		Args:  cobra.ExactArgs(0),
	}

	retval.SetHelpFunc(func(c *cobra.Command, args []string) {
		c.Printf("The following options can be passed to any command:\n")
		// (Currently the only global options we show are help options)
		rootCmd.PersistentFlags().VisitAll(func(flag *pflag.Flag) {

	return func(opts *options) {
		opts.unit = unit
	}
}

// WithEnabled allows a metric to be condition enabled if the provided function returns true.
// If disabled, metric operations will do nothing.
func WithEnabled(enabled func() bool) Options {
	return func(o *options) {
		o.enabledCondition = enabled
	}
}

func createOptions(name, description string, opts ...Options) (options, Metric) {

)

// Options defines the set of options used for grpc keepalive.
// The Time and Timeout options are used for both client and server connections,
// whereas MaxServerConnectionAge* options are applicable on the server side only
// (as implied by the options' name...)
type Options struct {