}
};

using ValuePortResultMap =
    absl::flat_hash_map<ValuePort, Attribute, ValuePortHasher>;
using ComputedQueryFn = function_ref<bool(ValuePort)>;
using ValueQueryFn = function_ref<Attribute(const ValuePort&)>;
using ValuePortInputs = SmallVectorImpl<ValuePort>;

// Note: Following implements the rank 1 pack op case so could be
// generalized.
//

  if (!status.ok()) {
    LOG(ERROR) << "Failed to remove functiondef " << name_ << ". "
               << status.message();
  }
}

Status FlatTensorFunction::Create(
    const FunctionDef* function_def,
    std::vector<ImmediateExecutionTensorHandle*> captures,
    ImmediateExecutionContext* ctx, std::unique_ptr<FlatTensorFunction>* out) {
  TF_RETURN_IF_ERROR(ctx->AddFunctionDef(*function_def));

  for (tensorflow::NodeDef& node_def : *graph_def.mutable_node()) {
    func(node_def);
  }

  for (tensorflow::FunctionDef& function_def :
       *graph_def.mutable_library()->mutable_function()) {
    for (tensorflow::NodeDef& node_def : *function_def.mutable_node_def()) {
      func(node_def);
    }
  }
}

}  // namespace stablehlo::quantization

  ASSERT_EQ(TF_GetCode(status), TF_OK) << TF_Message(status);

  // Register and run a function which returns the sum of 3 variables.
  const string function_def = AddVariablesFunction();
  TFE_ContextAddFunctionDef(ctx, function_def.data(), function_def.size(),
                            status);
  ASSERT_EQ(TF_GetCode(status), TF_OK) << TF_Message(status);

  TFE_Op* func = TFE_NewOp(ctx, "AddVariablesFunction", status);

 public:
  // Factory function for creating a TFConcreteFunction.
  //
  // Params:
  //  function_def - The function_def associated with the created
  //                 TFConcreteFunction. TFConcreteFunction will register this
  //                 function_def with `ctx` on creation, and de-register it on
  //                 destruction. function_def must be non-null, but
  //                 otherwise has no lifetime requirements.

  // Factory function for creating a TFSignatureDefFunction.
  //
  // Params:
  //  function_def - The function_def associated with the created
  //                 TFSignatureDefFunction. TFSignatureDefFunction will
  //                 register this function_def with `ctx` on creation, and
  //                 de-register it on destruction. function_def must be
  //                 non-null, but otherwise has no lifetime requirements.

gtl::FlatMap<StringPiece, const AttrValueMap*, StringPieceHasher> NodeToAttrMap(
    const tensorflow::GraphDef& graphdef);

// Maps the name of each FunctionDef in `library` to its corresponding
// FunctionDef. Callers must ensure `library` outlives the returned map.
gtl::FlatMap<StringPiece, const tensorflow::FunctionDef*, StringPieceHasher>
FunctionNameToFunctionDefMap(const FunctionDefLibrary& library);

Status ConvertMlirFunctionToFunctionLibraryDef(mlir::func::FuncOp func,
                                               const GraphExportConfig& configs,
                                               FunctionDef* function_def);

}  // namespace v2
}  // namespace tf2xla
}  // namespace tensorflow

Status ConvertMlirFunctionToFunctionLibraryDef(mlir::func::FuncOp func,
                                               const GraphExportConfig& configs,
                                               FunctionDef* function_def);
}  // namespace tensorflow

  }
  TaggedValue module = TaggedValue::Dict();

  // Initialize concrete function traces.
  const RepeatedPtrField<FunctionDef> function_defs =
      tf_package->GetFunctionDefs();
  absl::flat_hash_map<std::string, AbstractFunctionPtr> traces;
  for (auto& fdef : function_defs) {
    AbstractFunctionPtr trace(new GraphFunction(fdef), /*add_ref=*/false);
    traces[fdef.signature().name()] = trace;
  }