{{ else if (index .metadata.Labels "td.networking.gke.io/gateway-name") }}
      "id": "projects/{{ .gcp_project_number }}/networks/scope:{{ (index .metadata.Labels "td.networking.gke.io/gateway-name") }}/nodes/{{ .nodeID}}",
    {{ else }}
      "id": "projects/{{ .gcp_project_number }}/networks/default/nodes/{{ .nodeID}}",
    {{ end }}
    "cluster": "{{ .cluster }}",

    }

    private Map<String, Long> getUniqueIdsPerColor() {
        transformStepIdentities.collectEntries { color, identities ->
            def nodeIds = (identities*.transformStepNodeId as Set<Long>)
            [(color): Iterables.getOnlyElement(nodeIds)]
        }
    }

    private Map<String, List<Map<String, ?>>> getTransformStepIdentities() {

    uint32_t body_idx = opts->body_subgraph_index;
    if (body_idx >= func_names.size()) {
      return errors::InvalidArgument("subgraph with index not found: ",
                                     body_idx);
    }
    auto body_attr =
        mlir::SymbolRefAttr::get(builder.getContext(), func_names.at(body_idx));

    return llvm::SmallVector<mlir::NamedAttribute, 4>{

        "fieldsType": "fieldsTypeValue",
        "fieldsV1": {},
        "subresource": "subresourceValue"
      }
    ]
  },
  "spec": {
    "drivers": [
      {
        "name": "nameValue",
        "nodeID": "nodeIDValue",
        "topologyKeys": [
          "topologyKeysValue"
        ],
        "allocatable": {
          "count": 1
        }
      }
    ]
  }

// validateCSINodeDriverNodeID tests if Name in CSINodeDriver is a valid node id.
func validateCSINodeDriverNodeID(nodeID string, fldPath *field.Path, validationOpts CSINodeValidationOptions) field.ErrorList {
	allErrs := field.ErrorList{}

	// nodeID is always required
	if len(nodeID) == 0 {
		allErrs = append(allErrs, field.Required(fldPath, nodeID))
	}
	maxLength := csiNodeIDMaxLength
	if validationOpts.AllowLongNodeID {

    name: nameValue
    uid: uidValue
  resourceVersion: resourceVersionValue
  selfLink: selfLinkValue
  uid: uidValue
spec:
  drivers:
  - allocatable:
      count: 1
    name: nameValue
    nodeID: nodeIDValue
    topologyKeys:

    auto node_it = nodes_.find(input_inst);
    TF_RET_CHECK(node_it != nodes_.end())
        << "Use of OpResult encountered before def!";
    if (mlir::isa<mlir::tf_executor::ControlType>(input_result.getType())) {
      graph_->AddControlEdge(node_it->second, dst_node,
                             /*allow_duplicates=*/true);
    } else {

    auto node_it = nodes_.find(input_inst);
    TF_RET_CHECK(node_it != nodes_.end())
        << "Use of OpResult encountered before def!";
    if (mlir::isa<mlir::tf_executor::ControlType>(input_result.getType())) {
      graph_->AddControlEdge(node_it->second, dst_node,
                             /*allow_duplicates=*/true);
    } else {

        val scheduledEntryNodeIds = mutableListOf<Int>()
        nodes.forEach { node ->
            write(node)
            val nodeId = scheduledNodeIds.size
            scheduledNodeIds[node] = nodeId
            if (node in work.entryNodes) {
                scheduledEntryNodeIds.add(nodeId)
            }
            if (node is LocalTaskNode) {
                scheduledNodeIds[node.prepareNode] = scheduledNodeIds.size

            def nodeMatcher = matchers[0]
            def nodeId = getTypedNodeId(plannedNode.nodeIdentity)
            assert !usedMatchers.contains(nodeMatcher)
            usedMatchers.add(nodeMatcher)
            nodeIdByTypedNodeId[nodeId] = nodeMatcher.nodeId
            expectedDependencyNodeIdsByTypedNodeId[nodeId] = nodeMatcher.dependencyNodeIds
        }