diff --git a/CHANGELOG.md b/CHANGELOG.md
index ac8f323b77..68147e54d3 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5,6 +5,7 @@
 ### BREAKING
 
 - Code reorganisation, a lot of code has moved, please review the following PRs accordingly [#1444](https://github.com/juanfont/headscale/pull/1444)
+- Rename Machine into Node [#1553](https://github.com/juanfont/headscale/pull/1553)
 
 ### Changes
 
diff --git a/cmd/headscale/cli/debug.go b/cmd/headscale/cli/debug.go
index 7e8e92dc38..8250910e2c 100644
--- a/cmd/headscale/cli/debug.go
+++ b/cmd/headscale/cli/debug.go
@@ -57,7 +57,7 @@ var debugCmd = &cobra.Command{
 
 var createNodeCmd = &cobra.Command{
 	Use:   "create-node",
-	Short: "Create a node (machine) that can be registered with `nodes register <>` command",
+	Short: "Create a node that can be registered with `nodes register <>` command",
 	Run: func(cmd *cobra.Command, args []string) {
 		output, _ := cmd.Flags().GetString("output")
 
@@ -115,24 +115,24 @@ var createNodeCmd = &cobra.Command{
 			return
 		}
 
-		request := &v1.DebugCreateMachineRequest{
+		request := &v1.DebugCreateNodeRequest{
 			Key:    machineKey,
 			Name:   name,
 			User:   user,
 			Routes: routes,
 		}
 
-		response, err := client.DebugCreateMachine(ctx, request)
+		response, err := client.DebugCreateNode(ctx, request)
 		if err != nil {
 			ErrorOutput(
 				err,
-				fmt.Sprintf("Cannot create machine: %s", status.Convert(err).Message()),
+				fmt.Sprintf("Cannot create node: %s", status.Convert(err).Message()),
 				output,
 			)
 
 			return
 		}
 
-		SuccessOutput(response.Machine, "Machine created", output)
+		SuccessOutput(response.Node, "Node created", output)
 	},
 }
diff --git a/cmd/headscale/cli/nodes.go b/cmd/headscale/cli/nodes.go
index 31a0677394..055d2e3ed8 100644
--- a/cmd/headscale/cli/nodes.go
+++ b/cmd/headscale/cli/nodes.go
@@ -107,7 +107,7 @@ var nodeCmd = &cobra.Command{
 
 var registerNodeCmd = &cobra.Command{
 	Use:   "register",
-	Short: "Registers a machine to your network",
+	Short: "Registers a node to your network",
 	Run: func(cmd *cobra.Command, args []string) {
 		output, _ := cmd.Flags().GetString("output")
 		user, err := cmd.Flags().GetString("user")
@@ -132,17 +132,17 @@ var registerNodeCmd = &cobra.Command{
 			return
 		}
 
-		request := &v1.RegisterMachineRequest{
+		request := &v1.RegisterNodeRequest{
 			Key:  machineKey,
 			User: user,
 		}
 
-		response, err := client.RegisterMachine(ctx, request)
+		response, err := client.RegisterNode(ctx, request)
 		if err != nil {
 			ErrorOutput(
 				err,
 				fmt.Sprintf(
-					"Cannot register machine: %s\n",
+					"Cannot register node: %s\n",
 					status.Convert(err).Message(),
 				),
 				output,
@@ -152,8 +152,8 @@ var registerNodeCmd = &cobra.Command{
 		}
 
 		SuccessOutput(
-			response.Machine,
-			fmt.Sprintf("Machine %s registered", response.Machine.GivenName), output)
+			response.Node,
+			fmt.Sprintf("Node %s registered", response.Node.GivenName), output)
 	},
 }
 
@@ -180,11 +180,11 @@ var listNodesCmd = &cobra.Command{
 		defer cancel()
 		defer conn.Close()
 
-		request := &v1.ListMachinesRequest{
+		request := &v1.ListNodesRequest{
 			User: user,
 		}
 
-		response, err := client.ListMachines(ctx, request)
+		response, err := client.ListNodes(ctx, request)
 		if err != nil {
 			ErrorOutput(
 				err,
@@ -196,12 +196,12 @@ var listNodesCmd = &cobra.Command{
 		}
 
 		if output != "" {
-			SuccessOutput(response.Machines, "", output)
+			SuccessOutput(response.Nodes, "", output)
 
 			return
 		}
 
-		tableData, err := nodesToPtables(user, showTags, response.Machines)
+		tableData, err := nodesToPtables(user, showTags, response.Nodes)
 		if err != nil {
 			ErrorOutput(err, fmt.Sprintf("Error converting to table: %s", err), output)
 
@@ -223,7 +223,7 @@ var listNodesCmd = &cobra.Command{
 
 var expireNodeCmd = &cobra.Command{
 	Use:     "expire",
-	Short:   "Expire (log out) a machine in your network",
+	Short:   "Expire (log out) a node in your network",
 	Long:    "Expiring a node will keep the node in the database and force it to reauthenticate.",
 	Aliases: []string{"logout", "exp", "e"},
 	Run: func(cmd *cobra.Command, args []string) {
@@ -244,16 +244,16 @@ var expireNodeCmd = &cobra.Command{
 		defer cancel()
 		defer conn.Close()
 
-		request := &v1.ExpireMachineRequest{
-			MachineId: identifier,
+		request := &v1.ExpireNodeRequest{
+			NodeId: identifier,
 		}
 
-		response, err := client.ExpireMachine(ctx, request)
+		response, err := client.ExpireNode(ctx, request)
 		if err != nil {
 			ErrorOutput(
 				err,
 				fmt.Sprintf(
-					"Cannot expire machine: %s\n",
+					"Cannot expire node: %s\n",
 					status.Convert(err).Message(),
 				),
 				output,
@@ -262,13 +262,13 @@ var expireNodeCmd = &cobra.Command{
 			return
 		}
 
-		SuccessOutput(response.Machine, "Machine expired", output)
+		SuccessOutput(response.Node, "Node expired", output)
 	},
 }
 
 var renameNodeCmd = &cobra.Command{
 	Use:   "rename NEW_NAME",
-	Short: "Renames a machine in your network",
+	Short: "Renames a node in your network",
 	Run: func(cmd *cobra.Command, args []string) {
 		output, _ := cmd.Flags().GetString("output")
 
@@ -291,17 +291,17 @@ var renameNodeCmd = &cobra.Command{
 		if len(args) > 0 {
 			newName = args[0]
 		}
-		request := &v1.RenameMachineRequest{
-			MachineId: identifier,
-			NewName:   newName,
+		request := &v1.RenameNodeRequest{
+			NodeId:  identifier,
+			NewName: newName,
 		}
 
-		response, err := client.RenameMachine(ctx, request)
+		response, err := client.RenameNode(ctx, request)
 		if err != nil {
 			ErrorOutput(
 				err,
 				fmt.Sprintf(
-					"Cannot rename machine: %s\n",
+					"Cannot rename node: %s\n",
 					status.Convert(err).Message(),
 				),
 				output,
@@ -310,7 +310,7 @@ var renameNodeCmd = &cobra.Command{
 			return
 		}
 
-		SuccessOutput(response.Machine, "Machine renamed", output)
+		SuccessOutput(response.Node, "Node renamed", output)
 	},
 }
 
@@ -336,11 +336,11 @@ var deleteNodeCmd = &cobra.Command{
 		defer cancel()
 		defer conn.Close()
 
-		getRequest := &v1.GetMachineRequest{
-			MachineId: identifier,
+		getRequest := &v1.GetNodeRequest{
+			NodeId: identifier,
 		}
 
-		getResponse, err := client.GetMachine(ctx, getRequest)
+		getResponse, err := client.GetNode(ctx, getRequest)
 		if err != nil {
 			ErrorOutput(
 				err,
@@ -354,8 +354,8 @@ var deleteNodeCmd = &cobra.Command{
 			return
 		}
 
-		deleteRequest := &v1.DeleteMachineRequest{
-			MachineId: identifier,
+		deleteRequest := &v1.DeleteNodeRequest{
+			NodeId: identifier,
 		}
 
 		confirm := false
@@ -364,7 +364,7 @@ var deleteNodeCmd = &cobra.Command{
 			prompt := &survey.Confirm{
 				Message: fmt.Sprintf(
 					"Do you want to remove the node %s?",
-					getResponse.GetMachine().Name,
+					getResponse.GetNode().Name,
 				),
 			}
 			err = survey.AskOne(prompt, &confirm)
@@ -374,7 +374,7 @@ var deleteNodeCmd = &cobra.Command{
 		}
 
 		if confirm || force {
-			response, err := client.DeleteMachine(ctx, deleteRequest)
+			response, err := client.DeleteNode(ctx, deleteRequest)
 			if output != "" {
 				SuccessOutput(response, "", output)
 
@@ -436,11 +436,11 @@ var moveNodeCmd = &cobra.Command{
 		defer cancel()
 		defer conn.Close()
 
-		getRequest := &v1.GetMachineRequest{
-			MachineId: identifier,
+		getRequest := &v1.GetNodeRequest{
+			NodeId: identifier,
 		}
 
-		_, err = client.GetMachine(ctx, getRequest)
+		_, err = client.GetNode(ctx, getRequest)
 		if err != nil {
 			ErrorOutput(
 				err,
@@ -454,12 +454,12 @@ var moveNodeCmd = &cobra.Command{
 			return
 		}
 
-		moveRequest := &v1.MoveMachineRequest{
-			MachineId: identifier,
-			User:      user,
+		moveRequest := &v1.MoveNodeRequest{
+			NodeId: identifier,
+			User:   user,
 		}
 
-		moveResponse, err := client.MoveMachine(ctx, moveRequest)
+		moveResponse, err := client.MoveNode(ctx, moveRequest)
 		if err != nil {
 			ErrorOutput(
 				err,
@@ -473,14 +473,14 @@ var moveNodeCmd = &cobra.Command{
 			return
 		}
 
-		SuccessOutput(moveResponse.Machine, "Node moved to another user", output)
+		SuccessOutput(moveResponse.Node, "Node moved to another user", output)
 	},
 }
 
 func nodesToPtables(
 	currentUser string,
 	showTags bool,
-	machines []*v1.Machine,
+	nodes []*v1.Node,
 ) (pterm.TableData, error) {
 	tableHeader := []string{
 		"ID",
@@ -505,23 +505,23 @@ func nodesToPtables(
 	}
 	tableData := pterm.TableData{tableHeader}
 
-	for _, machine := range machines {
+	for _, node := range nodes {
 		var ephemeral bool
-		if machine.PreAuthKey != nil && machine.PreAuthKey.Ephemeral {
+		if node.PreAuthKey != nil && node.PreAuthKey.Ephemeral {
 			ephemeral = true
 		}
 
 		var lastSeen time.Time
 		var lastSeenTime string
-		if machine.LastSeen != nil {
-			lastSeen = machine.LastSeen.AsTime()
+		if node.LastSeen != nil {
+			lastSeen = node.LastSeen.AsTime()
 			lastSeenTime = lastSeen.Format("2006-01-02 15:04:05")
 		}
 
 		var expiry time.Time
 		var expiryTime string
-		if machine.Expiry != nil {
-			expiry = machine.Expiry.AsTime()
+		if node.Expiry != nil {
+			expiry = node.Expiry.AsTime()
 			expiryTime = expiry.Format("2006-01-02 15:04:05")
 		} else {
 			expiryTime = "N/A"
@@ -529,7 +529,7 @@ func nodesToPtables(
 
 		var machineKey key.MachinePublic
 		err := machineKey.UnmarshalText(
-			[]byte(util.MachinePublicKeyEnsurePrefix(machine.MachineKey)),
+			[]byte(util.MachinePublicKeyEnsurePrefix(node.MachineKey)),
 		)
 		if err != nil {
 			machineKey = key.MachinePublic{}
@@ -537,14 +537,14 @@ func nodesToPtables(
 
 		var nodeKey key.NodePublic
 		err = nodeKey.UnmarshalText(
-			[]byte(util.NodePublicKeyEnsurePrefix(machine.NodeKey)),
+			[]byte(util.NodePublicKeyEnsurePrefix(node.NodeKey)),
 		)
 		if err != nil {
 			return nil, err
 		}
 
 		var online string
-		if machine.Online {
+		if node.Online {
 			online = pterm.LightGreen("online")
 		} else {
 			online = pterm.LightRed("offline")
@@ -558,36 +558,36 @@ func nodesToPtables(
 		}
 
 		var forcedTags string
-		for _, tag := range machine.ForcedTags {
+		for _, tag := range node.ForcedTags {
 			forcedTags += "," + tag
 		}
 		forcedTags = strings.TrimLeft(forcedTags, ",")
 		var invalidTags string
-		for _, tag := range machine.InvalidTags {
-			if !contains(machine.ForcedTags, tag) {
+		for _, tag := range node.InvalidTags {
+			if !contains(node.ForcedTags, tag) {
 				invalidTags += "," + pterm.LightRed(tag)
 			}
 		}
 		invalidTags = strings.TrimLeft(invalidTags, ",")
 		var validTags string
-		for _, tag := range machine.ValidTags {
-			if !contains(machine.ForcedTags, tag) {
+		for _, tag := range node.ValidTags {
+			if !contains(node.ForcedTags, tag) {
 				validTags += "," + pterm.LightGreen(tag)
 			}
 		}
 		validTags = strings.TrimLeft(validTags, ",")
 
 		var user string
-		if currentUser == "" || (currentUser == machine.User.Name) {
-			user = pterm.LightMagenta(machine.User.Name)
+		if currentUser == "" || (currentUser == node.User.Name) {
+			user = pterm.LightMagenta(node.User.Name)
 		} else {
 			// Shared into this user
-			user = pterm.LightYellow(machine.User.Name)
+			user = pterm.LightYellow(node.User.Name)
 		}
 
 		var IPV4Address string
 		var IPV6Address string
-		for _, addr := range machine.IpAddresses {
+		for _, addr := range node.IpAddresses {
 			if netip.MustParseAddr(addr).Is4() {
 				IPV4Address = addr
 			} else {
@@ -596,9 +596,9 @@ func nodesToPtables(
 		}
 
 		nodeData := []string{
-			strconv.FormatUint(machine.Id, util.Base10),
-			machine.Name,
-			machine.GetGivenName(),
+			strconv.FormatUint(node.Id, util.Base10),
+			node.Name,
+			node.GetGivenName(),
 			machineKey.ShortString(),
 			nodeKey.ShortString(),
 			user,
@@ -646,17 +646,17 @@ var tagCmd = &cobra.Command{
 		if err != nil {
 			ErrorOutput(
 				err,
-				fmt.Sprintf("Error retrieving list of tags to add to machine, %v", err),
+				fmt.Sprintf("Error retrieving list of tags to add to node, %v", err),
 				output,
 			)
 
 			return
 		}
 
-		// Sending tags to machine
+		// Sending tags to node
 		request := &v1.SetTagsRequest{
-			MachineId: identifier,
-			Tags:      tagsToSet,
+			NodeId: identifier,
+			Tags:   tagsToSet,
 		}
 		resp, err := client.SetTags(ctx, request)
 		if err != nil {
@@ -671,8 +671,8 @@ var tagCmd = &cobra.Command{
 
 		if resp != nil {
 			SuccessOutput(
-				resp.GetMachine(),
-				"Machine updated",
+				resp.GetNode(),
+				"Node updated",
 				output,
 			)
 		}
diff --git a/cmd/headscale/cli/root.go b/cmd/headscale/cli/root.go
index 6c788aa373..40a9b18ad6 100644
--- a/cmd/headscale/cli/root.go
+++ b/cmd/headscale/cli/root.go
@@ -58,7 +58,7 @@ func initConfig() {
 
 	zerolog.SetGlobalLevel(cfg.Log.Level)
 
-	// If the user has requested a "machine" readable format,
+	// If the user has requested a "node" readable format,
 	// then disable login so the output remains valid.
 	if machineOutput {
 		zerolog.SetGlobalLevel(zerolog.Disabled)
diff --git a/cmd/headscale/cli/routes.go b/cmd/headscale/cli/routes.go
index 90dd51a852..1872cbc780 100644
--- a/cmd/headscale/cli/routes.go
+++ b/cmd/headscale/cli/routes.go
@@ -94,13 +94,13 @@ var listRoutesCmd = &cobra.Command{
 
 			routes = response.Routes
 		} else {
-			response, err := client.GetMachineRoutes(ctx, &v1.GetMachineRoutesRequest{
-				MachineId: machineID,
+			response, err := client.GetNodeRoutes(ctx, &v1.GetNodeRoutesRequest{
+				NodeId: machineID,
 			})
 			if err != nil {
 				ErrorOutput(
 					err,
-					fmt.Sprintf("Cannot get routes for machine %d: %s", machineID, status.Convert(err).Message()),
+					fmt.Sprintf("Cannot get routes for node %d: %s", machineID, status.Convert(err).Message()),
 					output,
 				)
 
@@ -267,7 +267,7 @@ var deleteRouteCmd = &cobra.Command{
 
 // routesToPtables converts the list of routes to a nice table.
 func routesToPtables(routes []*v1.Route) pterm.TableData {
-	tableData := pterm.TableData{{"ID", "Machine", "Prefix", "Advertised", "Enabled", "Primary"}}
+	tableData := pterm.TableData{{"ID", "Node", "Prefix", "Advertised", "Enabled", "Primary"}}
 
 	for _, route := range routes {
 		var isPrimaryStr string
@@ -286,7 +286,7 @@ func routesToPtables(routes []*v1.Route) pterm.TableData {
 		tableData = append(tableData,
 			[]string{
 				strconv.FormatUint(route.Id, Base10),
-				route.Machine.GivenName,
+				route.Node.GivenName,
 				route.Prefix,
 				strconv.FormatBool(route.Advertised),
 				strconv.FormatBool(route.Enabled),
diff --git a/gen/go/headscale/v1/apikey.pb.go b/gen/go/headscale/v1/apikey.pb.go
index cebca90d16..3e1ebd9c04 100644
--- a/gen/go/headscale/v1/apikey.pb.go
+++ b/gen/go/headscale/v1/apikey.pb.go
@@ -1,6 +1,6 @@
 // Code generated by protoc-gen-go. DO NOT EDIT.
 // versions:
-// 	protoc-gen-go v1.29.1
+// 	protoc-gen-go v1.31.0
 // 	protoc        (unknown)
 // source: headscale/v1/apikey.proto
 
diff --git a/gen/go/headscale/v1/device.pb.go b/gen/go/headscale/v1/device.pb.go
index 6d626c9d35..1de3084ffc 100644
--- a/gen/go/headscale/v1/device.pb.go
+++ b/gen/go/headscale/v1/device.pb.go
@@ -1,6 +1,6 @@
 // Code generated by protoc-gen-go. DO NOT EDIT.
 // versions:
-// 	protoc-gen-go v1.29.1
+// 	protoc-gen-go v1.31.0
 // 	protoc        (unknown)
 // source: headscale/v1/device.proto
 
diff --git a/gen/go/headscale/v1/headscale.pb.go b/gen/go/headscale/v1/headscale.pb.go
index d29ab04b10..9917fd8150 100644
--- a/gen/go/headscale/v1/headscale.pb.go
+++ b/gen/go/headscale/v1/headscale.pb.go
@@ -1,6 +1,6 @@
 // Code generated by protoc-gen-go. DO NOT EDIT.
 // versions:
-// 	protoc-gen-go v1.29.1
+// 	protoc-gen-go v1.31.0
 // 	protoc        (unknown)
 // source: headscale/v1/headscale.proto
 
@@ -31,261 +31,252 @@ var file_headscale_v1_headscale_proto_rawDesc = []byte{
 	0x73, 0x63, 0x61, 0x6c, 0x65, 0x2f, 0x76, 0x31, 0x2f, 0x75, 0x73, 0x65, 0x72, 0x2e, 0x70, 0x72,
 	0x6f, 0x74, 0x6f, 0x1a, 0x1d, 0x68, 0x65, 0x61, 0x64, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x2f, 0x76,
 	0x31, 0x2f, 0x70, 0x72, 0x65, 0x61, 0x75, 0x74, 0x68, 0x6b, 0x65, 0x79, 0x2e, 0x70, 0x72, 0x6f,
-	0x74, 0x6f, 0x1a, 0x1a, 0x68, 0x65, 0x61, 0x64, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x2f, 0x76, 0x31,
-	0x2f, 0x6d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x19,
-	0x68, 0x65, 0x61, 0x64, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x2f, 0x76, 0x31, 0x2f, 0x72, 0x6f, 0x75,
-	0x74, 0x65, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x19, 0x68, 0x65, 0x61, 0x64, 0x73,
-	0x63, 0x61, 0x6c, 0x65, 0x2f, 0x76, 0x31, 0x2f, 0x61, 0x70, 0x69, 0x6b, 0x65, 0x79, 0x2e, 0x70,
-	0x72, 0x6f, 0x74, 0x6f, 0x32, 0x8d, 0x18, 0x0a, 0x10, 0x48, 0x65, 0x61, 0x64, 0x73, 0x63, 0x61,
-	0x6c, 0x65, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x63, 0x0a, 0x07, 0x47, 0x65, 0x74,
-	0x55, 0x73, 0x65, 0x72, 0x12, 0x1c, 0x2e, 0x68, 0x65, 0x61, 0x64, 0x73, 0x63, 0x61, 0x6c, 0x65,
-	0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x55, 0x73, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65,
-	0x73, 0x74, 0x1a, 0x1d, 0x2e, 0x68, 0x65, 0x61, 0x64, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x2e, 0x76,
-	0x31, 0x2e, 0x47, 0x65, 0x74, 0x55, 0x73, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73,
-	0x65, 0x22, 0x1b, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x15, 0x12, 0x13, 0x2f, 0x61, 0x70, 0x69, 0x2f,
-	0x76, 0x31, 0x2f, 0x75, 0x73, 0x65, 0x72, 0x2f, 0x7b, 0x6e, 0x61, 0x6d, 0x65, 0x7d, 0x12, 0x68,
-	0x0a, 0x0a, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x55, 0x73, 0x65, 0x72, 0x12, 0x1f, 0x2e, 0x68,
-	0x65, 0x61, 0x64, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x72, 0x65, 0x61,
-	0x74, 0x65, 0x55, 0x73, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x20, 0x2e,
-	0x68, 0x65, 0x61, 0x64, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x72, 0x65,
-	0x61, 0x74, 0x65, 0x55, 0x73, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22,
-	0x17, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x11, 0x3a, 0x01, 0x2a, 0x22, 0x0c, 0x2f, 0x61, 0x70, 0x69,
-	0x2f, 0x76, 0x31, 0x2f, 0x75, 0x73, 0x65, 0x72, 0x12, 0x82, 0x01, 0x0a, 0x0a, 0x52, 0x65, 0x6e,
-	0x61, 0x6d, 0x65, 0x55, 0x73, 0x65, 0x72, 0x12, 0x1f, 0x2e, 0x68, 0x65, 0x61, 0x64, 0x73, 0x63,
-	0x61, 0x6c, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x6e, 0x61, 0x6d, 0x65, 0x55, 0x73, 0x65,
-	0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x20, 0x2e, 0x68, 0x65, 0x61, 0x64, 0x73,
-	0x63, 0x61, 0x6c, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x6e, 0x61, 0x6d, 0x65, 0x55, 0x73,
-	0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x31, 0x82, 0xd3, 0xe4, 0x93,
-	0x02, 0x2b, 0x22, 0x29, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x75, 0x73, 0x65, 0x72,
-	0x2f, 0x7b, 0x6f, 0x6c, 0x64, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x7d, 0x2f, 0x72, 0x65, 0x6e, 0x61,
-	0x6d, 0x65, 0x2f, 0x7b, 0x6e, 0x65, 0x77, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x7d, 0x12, 0x6c, 0x0a,
-	0x0a, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x55, 0x73, 0x65, 0x72, 0x12, 0x1f, 0x2e, 0x68, 0x65,
-	0x61, 0x64, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74,
-	0x65, 0x55, 0x73, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x20, 0x2e, 0x68,
-	0x65, 0x61, 0x64, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65, 0x6c, 0x65,
-	0x74, 0x65, 0x55, 0x73, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1b,
-	0x82, 0xd3, 0xe4, 0x93, 0x02, 0x15, 0x2a, 0x13, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f,
-	0x75, 0x73, 0x65, 0x72, 0x2f, 0x7b, 0x6e, 0x61, 0x6d, 0x65, 0x7d, 0x12, 0x62, 0x0a, 0x09, 0x4c,
-	0x69, 0x73, 0x74, 0x55, 0x73, 0x65, 0x72, 0x73, 0x12, 0x1e, 0x2e, 0x68, 0x65, 0x61, 0x64, 0x73,
-	0x63, 0x61, 0x6c, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x55, 0x73, 0x65, 0x72,
-	0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1f, 0x2e, 0x68, 0x65, 0x61, 0x64, 0x73,
-	0x63, 0x61, 0x6c, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x55, 0x73, 0x65, 0x72,
-	0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x14, 0x82, 0xd3, 0xe4, 0x93, 0x02,
-	0x0e, 0x12, 0x0c, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x75, 0x73, 0x65, 0x72, 0x12,
-	0x80, 0x01, 0x0a, 0x10, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x50, 0x72, 0x65, 0x41, 0x75, 0x74,
+	0x74, 0x6f, 0x1a, 0x17, 0x68, 0x65, 0x61, 0x64, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x2f, 0x76, 0x31,
+	0x2f, 0x6e, 0x6f, 0x64, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x19, 0x68, 0x65, 0x61,
+	0x64, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x2f, 0x76, 0x31, 0x2f, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x73,
+	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x19, 0x68, 0x65, 0x61, 0x64, 0x73, 0x63, 0x61, 0x6c,
+	0x65, 0x2f, 0x76, 0x31, 0x2f, 0x61, 0x70, 0x69, 0x6b, 0x65, 0x79, 0x2e, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x32, 0x85, 0x17, 0x0a, 0x10, 0x48, 0x65, 0x61, 0x64, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x53,
+	0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x63, 0x0a, 0x07, 0x47, 0x65, 0x74, 0x55, 0x73, 0x65,
+	0x72, 0x12, 0x1c, 0x2e, 0x68, 0x65, 0x61, 0x64, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x2e, 0x76, 0x31,
+	0x2e, 0x47, 0x65, 0x74, 0x55, 0x73, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a,
+	0x1d, 0x2e, 0x68, 0x65, 0x61, 0x64, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x47,
+	0x65, 0x74, 0x55, 0x73, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1b,
+	0x82, 0xd3, 0xe4, 0x93, 0x02, 0x15, 0x12, 0x13, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f,
+	0x75, 0x73, 0x65, 0x72, 0x2f, 0x7b, 0x6e, 0x61, 0x6d, 0x65, 0x7d, 0x12, 0x68, 0x0a, 0x0a, 0x43,
+	0x72, 0x65, 0x61, 0x74, 0x65, 0x55, 0x73, 0x65, 0x72, 0x12, 0x1f, 0x2e, 0x68, 0x65, 0x61, 0x64,
+	0x73, 0x63, 0x61, 0x6c, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x55,
+	0x73, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x20, 0x2e, 0x68, 0x65, 0x61,
+	0x64, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65,
+	0x55, 0x73, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x17, 0x82, 0xd3,
+	0xe4, 0x93, 0x02, 0x11, 0x3a, 0x01, 0x2a, 0x22, 0x0c, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31,
+	0x2f, 0x75, 0x73, 0x65, 0x72, 0x12, 0x82, 0x01, 0x0a, 0x0a, 0x52, 0x65, 0x6e, 0x61, 0x6d, 0x65,
+	0x55, 0x73, 0x65, 0x72, 0x12, 0x1f, 0x2e, 0x68, 0x65, 0x61, 0x64, 0x73, 0x63, 0x61, 0x6c, 0x65,
+	0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x6e, 0x61, 0x6d, 0x65, 0x55, 0x73, 0x65, 0x72, 0x52, 0x65,
+	0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x20, 0x2e, 0x68, 0x65, 0x61, 0x64, 0x73, 0x63, 0x61, 0x6c,
+	0x65, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x6e, 0x61, 0x6d, 0x65, 0x55, 0x73, 0x65, 0x72, 0x52,
+	0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x31, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x2b, 0x22,
+	0x29, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x75, 0x73, 0x65, 0x72, 0x2f, 0x7b, 0x6f,
+	0x6c, 0x64, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x7d, 0x2f, 0x72, 0x65, 0x6e, 0x61, 0x6d, 0x65, 0x2f,
+	0x7b, 0x6e, 0x65, 0x77, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x7d, 0x12, 0x6c, 0x0a, 0x0a, 0x44, 0x65,
+	0x6c, 0x65, 0x74, 0x65, 0x55, 0x73, 0x65, 0x72, 0x12, 0x1f, 0x2e, 0x68, 0x65, 0x61, 0x64, 0x73,
+	0x63, 0x61, 0x6c, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x55, 0x73,
+	0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x20, 0x2e, 0x68, 0x65, 0x61, 0x64,
+	0x73, 0x63, 0x61, 0x6c, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x55,
+	0x73, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1b, 0x82, 0xd3, 0xe4,
+	0x93, 0x02, 0x15, 0x2a, 0x13, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x75, 0x73, 0x65,
+	0x72, 0x2f, 0x7b, 0x6e, 0x61, 0x6d, 0x65, 0x7d, 0x12, 0x62, 0x0a, 0x09, 0x4c, 0x69, 0x73, 0x74,
+	0x55, 0x73, 0x65, 0x72, 0x73, 0x12, 0x1e, 0x2e, 0x68, 0x65, 0x61, 0x64, 0x73, 0x63, 0x61, 0x6c,
+	0x65, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x55, 0x73, 0x65, 0x72, 0x73, 0x52, 0x65,
+	0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1f, 0x2e, 0x68, 0x65, 0x61, 0x64, 0x73, 0x63, 0x61, 0x6c,
+	0x65, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x55, 0x73, 0x65, 0x72, 0x73, 0x52, 0x65,
+	0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x14, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x0e, 0x12, 0x0c,
+	0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x75, 0x73, 0x65, 0x72, 0x12, 0x80, 0x01, 0x0a,
+	0x10, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x50, 0x72, 0x65, 0x41, 0x75, 0x74, 0x68, 0x4b, 0x65,
+	0x79, 0x12, 0x25, 0x2e, 0x68, 0x65, 0x61, 0x64, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x2e, 0x76, 0x31,
+	0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x50, 0x72, 0x65, 0x41, 0x75, 0x74, 0x68, 0x4b, 0x65,
+	0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x26, 0x2e, 0x68, 0x65, 0x61, 0x64, 0x73,
+	0x63, 0x61, 0x6c, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x50, 0x72,
+	0x65, 0x41, 0x75, 0x74, 0x68, 0x4b, 0x65, 0x79, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
+	0x22, 0x1d, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x17, 0x3a, 0x01, 0x2a, 0x22, 0x12, 0x2f, 0x61, 0x70,
+	0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x72, 0x65, 0x61, 0x75, 0x74, 0x68, 0x6b, 0x65, 0x79, 0x12,
+	0x87, 0x01, 0x0a, 0x10, 0x45, 0x78, 0x70, 0x69, 0x72, 0x65, 0x50, 0x72, 0x65, 0x41, 0x75, 0x74,
 	0x68, 0x4b, 0x65, 0x79, 0x12, 0x25, 0x2e, 0x68, 0x65, 0x61, 0x64, 0x73, 0x63, 0x61, 0x6c, 0x65,
-	0x2e, 0x76, 0x31, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x50, 0x72, 0x65, 0x41, 0x75, 0x74,
+	0x2e, 0x76, 0x31, 0x2e, 0x45, 0x78, 0x70, 0x69, 0x72, 0x65, 0x50, 0x72, 0x65, 0x41, 0x75, 0x74,
 	0x68, 0x4b, 0x65, 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x26, 0x2e, 0x68, 0x65,
-	0x61, 0x64, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74,
+	0x61, 0x64, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x45, 0x78, 0x70, 0x69, 0x72,
 	0x65, 0x50, 0x72, 0x65, 0x41, 0x75, 0x74, 0x68, 0x4b, 0x65, 0x79, 0x52, 0x65, 0x73, 0x70, 0x6f,
-	0x6e, 0x73, 0x65, 0x22, 0x1d, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x17, 0x3a, 0x01, 0x2a, 0x22, 0x12,
+	0x6e, 0x73, 0x65, 0x22, 0x24, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1e, 0x3a, 0x01, 0x2a, 0x22, 0x19,
 	0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x72, 0x65, 0x61, 0x75, 0x74, 0x68, 0x6b,
-	0x65, 0x79, 0x12, 0x87, 0x01, 0x0a, 0x10, 0x45, 0x78, 0x70, 0x69, 0x72, 0x65, 0x50, 0x72, 0x65,
-	0x41, 0x75, 0x74, 0x68, 0x4b, 0x65, 0x79, 0x12, 0x25, 0x2e, 0x68, 0x65, 0x61, 0x64, 0x73, 0x63,
-	0x61, 0x6c, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x45, 0x78, 0x70, 0x69, 0x72, 0x65, 0x50, 0x72, 0x65,
-	0x41, 0x75, 0x74, 0x68, 0x4b, 0x65, 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x26,
-	0x2e, 0x68, 0x65, 0x61, 0x64, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x45, 0x78,
-	0x70, 0x69, 0x72, 0x65, 0x50, 0x72, 0x65, 0x41, 0x75, 0x74, 0x68, 0x4b, 0x65, 0x79, 0x52, 0x65,
-	0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x24, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1e, 0x3a, 0x01,
-	0x2a, 0x22, 0x19, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x72, 0x65, 0x61, 0x75,
-	0x74, 0x68, 0x6b, 0x65, 0x79, 0x2f, 0x65, 0x78, 0x70, 0x69, 0x72, 0x65, 0x12, 0x7a, 0x0a, 0x0f,
-	0x4c, 0x69, 0x73, 0x74, 0x50, 0x72, 0x65, 0x41, 0x75, 0x74, 0x68, 0x4b, 0x65, 0x79, 0x73, 0x12,
-	0x24, 0x2e, 0x68, 0x65, 0x61, 0x64, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x4c,
-	0x69, 0x73, 0x74, 0x50, 0x72, 0x65, 0x41, 0x75, 0x74, 0x68, 0x4b, 0x65, 0x79, 0x73, 0x52, 0x65,
-	0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x25, 0x2e, 0x68, 0x65, 0x61, 0x64, 0x73, 0x63, 0x61, 0x6c,
-	0x65, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x50, 0x72, 0x65, 0x41, 0x75, 0x74, 0x68,
-	0x4b, 0x65, 0x79, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1a, 0x82, 0xd3,
-	0xe4, 0x93, 0x02, 0x14, 0x12, 0x12, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x72,
-	0x65, 0x61, 0x75, 0x74, 0x68, 0x6b, 0x65, 0x79, 0x12, 0x89, 0x01, 0x0a, 0x12, 0x44, 0x65, 0x62,
-	0x75, 0x67, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x4d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x12,
-	0x27, 0x2e, 0x68, 0x65, 0x61, 0x64, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x44,
-	0x65, 0x62, 0x75, 0x67, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x4d, 0x61, 0x63, 0x68, 0x69, 0x6e,
-	0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x28, 0x2e, 0x68, 0x65, 0x61, 0x64, 0x73,
+	0x65, 0x79, 0x2f, 0x65, 0x78, 0x70, 0x69, 0x72, 0x65, 0x12, 0x7a, 0x0a, 0x0f, 0x4c, 0x69, 0x73,
+	0x74, 0x50, 0x72, 0x65, 0x41, 0x75, 0x74, 0x68, 0x4b, 0x65, 0x79, 0x73, 0x12, 0x24, 0x2e, 0x68,
+	0x65, 0x61, 0x64, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74,
+	0x50, 0x72, 0x65, 0x41, 0x75, 0x74, 0x68, 0x4b, 0x65, 0x79, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65,
+	0x73, 0x74, 0x1a, 0x25, 0x2e, 0x68, 0x65, 0x61, 0x64, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x2e, 0x76,
+	0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x50, 0x72, 0x65, 0x41, 0x75, 0x74, 0x68, 0x4b, 0x65, 0x79,
+	0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1a, 0x82, 0xd3, 0xe4, 0x93, 0x02,
+	0x14, 0x12, 0x12, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x72, 0x65, 0x61, 0x75,
+	0x74, 0x68, 0x6b, 0x65, 0x79, 0x12, 0x7d, 0x0a, 0x0f, 0x44, 0x65, 0x62, 0x75, 0x67, 0x43, 0x72,
+	0x65, 0x61, 0x74, 0x65, 0x4e, 0x6f, 0x64, 0x65, 0x12, 0x24, 0x2e, 0x68, 0x65, 0x61, 0x64, 0x73,
 	0x63, 0x61, 0x6c, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65, 0x62, 0x75, 0x67, 0x43, 0x72, 0x65,
-	0x61, 0x74, 0x65, 0x4d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e,
-	0x73, 0x65, 0x22, 0x20, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1a, 0x3a, 0x01, 0x2a, 0x22, 0x15, 0x2f,
-	0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x64, 0x65, 0x62, 0x75, 0x67, 0x2f, 0x6d, 0x61, 0x63,
-	0x68, 0x69, 0x6e, 0x65, 0x12, 0x75, 0x0a, 0x0a, 0x47, 0x65, 0x74, 0x4d, 0x61, 0x63, 0x68, 0x69,
-	0x6e, 0x65, 0x12, 0x1f, 0x2e, 0x68, 0x65, 0x61, 0x64, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x2e, 0x76,
-	0x31, 0x2e, 0x47, 0x65, 0x74, 0x4d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x52, 0x65, 0x71, 0x75,
-	0x65, 0x73, 0x74, 0x1a, 0x20, 0x2e, 0x68, 0x65, 0x61, 0x64, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x2e,
-	0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x4d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x52, 0x65, 0x73,
-	0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x24, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1e, 0x12, 0x1c, 0x2f,
-	0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x6d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x2f, 0x7b,
-	0x6d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x5f, 0x69, 0x64, 0x7d, 0x12, 0x74, 0x0a, 0x07, 0x53,
-	0x65, 0x74, 0x54, 0x61, 0x67, 0x73, 0x12, 0x1c, 0x2e, 0x68, 0x65, 0x61, 0x64, 0x73, 0x63, 0x61,
-	0x6c, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x65, 0x74, 0x54, 0x61, 0x67, 0x73, 0x52, 0x65, 0x71,
-	0x75, 0x65, 0x73, 0x74, 0x1a, 0x1d, 0x2e, 0x68, 0x65, 0x61, 0x64, 0x73, 0x63, 0x61, 0x6c, 0x65,
-	0x2e, 0x76, 0x31, 0x2e, 0x53, 0x65, 0x74, 0x54, 0x61, 0x67, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f,
-	0x6e, 0x73, 0x65, 0x22, 0x2c, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x26, 0x3a, 0x01, 0x2a, 0x22, 0x21,
-	0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x6d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x2f,
-	0x7b, 0x6d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x5f, 0x69, 0x64, 0x7d, 0x2f, 0x74, 0x61, 0x67,
-	0x73, 0x12, 0x80, 0x01, 0x0a, 0x0f, 0x52, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x4d, 0x61,
-	0x63, 0x68, 0x69, 0x6e, 0x65, 0x12, 0x24, 0x2e, 0x68, 0x65, 0x61, 0x64, 0x73, 0x63, 0x61, 0x6c,
-	0x65, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x4d, 0x61, 0x63,
-	0x68, 0x69, 0x6e, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x25, 0x2e, 0x68, 0x65,
-	0x61, 0x64, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x67, 0x69, 0x73,
-	0x74, 0x65, 0x72, 0x4d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e,
-	0x73, 0x65, 0x22, 0x20, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1a, 0x22, 0x18, 0x2f, 0x61, 0x70, 0x69,
-	0x2f, 0x76, 0x31, 0x2f, 0x6d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x2f, 0x72, 0x65, 0x67, 0x69,
-	0x73, 0x74, 0x65, 0x72, 0x12, 0x7e, 0x0a, 0x0d, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x4d, 0x61,
-	0x63, 0x68, 0x69, 0x6e, 0x65, 0x12, 0x22, 0x2e, 0x68, 0x65, 0x61, 0x64, 0x73, 0x63, 0x61, 0x6c,
-	0x65, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x4d, 0x61, 0x63, 0x68, 0x69,
-	0x6e, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x23, 0x2e, 0x68, 0x65, 0x61, 0x64,
-	0x73, 0x63, 0x61, 0x6c, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x4d,
-	0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x24,
-	0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1e, 0x2a, 0x1c, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f,
-	0x6d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x2f, 0x7b, 0x6d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65,
-	0x5f, 0x69, 0x64, 0x7d, 0x12, 0x85, 0x01, 0x0a, 0x0d, 0x45, 0x78, 0x70, 0x69, 0x72, 0x65, 0x4d,
-	0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x12, 0x22, 0x2e, 0x68, 0x65, 0x61, 0x64, 0x73, 0x63, 0x61,
-	0x6c, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x45, 0x78, 0x70, 0x69, 0x72, 0x65, 0x4d, 0x61, 0x63, 0x68,
-	0x69, 0x6e, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x23, 0x2e, 0x68, 0x65, 0x61,
-	0x64, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x45, 0x78, 0x70, 0x69, 0x72, 0x65,
-	0x4d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22,
-	0x2b, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x25, 0x22, 0x23, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31,
-	0x2f, 0x6d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x2f, 0x7b, 0x6d, 0x61, 0x63, 0x68, 0x69, 0x6e,
-	0x65, 0x5f, 0x69, 0x64, 0x7d, 0x2f, 0x65, 0x78, 0x70, 0x69, 0x72, 0x65, 0x12, 0x90, 0x01, 0x0a,
-	0x0d, 0x52, 0x65, 0x6e, 0x61, 0x6d, 0x65, 0x4d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x12, 0x22,
-	0x2e, 0x68, 0x65, 0x61, 0x64, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65,
-	0x6e, 0x61, 0x6d, 0x65, 0x4d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65,
-	0x73, 0x74, 0x1a, 0x23, 0x2e, 0x68, 0x65, 0x61, 0x64, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x2e, 0x76,
-	0x31, 0x2e, 0x52, 0x65, 0x6e, 0x61, 0x6d, 0x65, 0x4d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x52,
-	0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x36, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x30, 0x22,
-	0x2e, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x6d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65,
-	0x2f, 0x7b, 0x6d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x5f, 0x69, 0x64, 0x7d, 0x2f, 0x72, 0x65,
+	0x61, 0x74, 0x65, 0x4e, 0x6f, 0x64, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x25,
+	0x2e, 0x68, 0x65, 0x61, 0x64, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65,
+	0x62, 0x75, 0x67, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x4e, 0x6f, 0x64, 0x65, 0x52, 0x65, 0x73,
+	0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1d, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x17, 0x3a, 0x01, 0x2a,
+	0x22, 0x12, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x64, 0x65, 0x62, 0x75, 0x67, 0x2f,
+	0x6e, 0x6f, 0x64, 0x65, 0x12, 0x66, 0x0a, 0x07, 0x47, 0x65, 0x74, 0x4e, 0x6f, 0x64, 0x65, 0x12,
+	0x1c, 0x2e, 0x68, 0x65, 0x61, 0x64, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x47,
+	0x65, 0x74, 0x4e, 0x6f, 0x64, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1d, 0x2e,
+	0x68, 0x65, 0x61, 0x64, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74,
+	0x4e, 0x6f, 0x64, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1e, 0x82, 0xd3,
+	0xe4, 0x93, 0x02, 0x18, 0x12, 0x16, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x6e, 0x6f,
+	0x64, 0x65, 0x2f, 0x7b, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x69, 0x64, 0x7d, 0x12, 0x6e, 0x0a, 0x07,
+	0x53, 0x65, 0x74, 0x54, 0x61, 0x67, 0x73, 0x12, 0x1c, 0x2e, 0x68, 0x65, 0x61, 0x64, 0x73, 0x63,
+	0x61, 0x6c, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x65, 0x74, 0x54, 0x61, 0x67, 0x73, 0x52, 0x65,
+	0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1d, 0x2e, 0x68, 0x65, 0x61, 0x64, 0x73, 0x63, 0x61, 0x6c,
+	0x65, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x65, 0x74, 0x54, 0x61, 0x67, 0x73, 0x52, 0x65, 0x73, 0x70,
+	0x6f, 0x6e, 0x73, 0x65, 0x22, 0x26, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x20, 0x3a, 0x01, 0x2a, 0x22,
+	0x1b, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x6e, 0x6f, 0x64, 0x65, 0x2f, 0x7b, 0x6e,
+	0x6f, 0x64, 0x65, 0x5f, 0x69, 0x64, 0x7d, 0x2f, 0x74, 0x61, 0x67, 0x73, 0x12, 0x74, 0x0a, 0x0c,
+	0x52, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x4e, 0x6f, 0x64, 0x65, 0x12, 0x21, 0x2e, 0x68,
+	0x65, 0x61, 0x64, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x67, 0x69,
+	0x73, 0x74, 0x65, 0x72, 0x4e, 0x6f, 0x64, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a,
+	0x22, 0x2e, 0x68, 0x65, 0x61, 0x64, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x52,
+	0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x4e, 0x6f, 0x64, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f,
+	0x6e, 0x73, 0x65, 0x22, 0x1d, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x17, 0x22, 0x15, 0x2f, 0x61, 0x70,
+	0x69, 0x2f, 0x76, 0x31, 0x2f, 0x6e, 0x6f, 0x64, 0x65, 0x2f, 0x72, 0x65, 0x67, 0x69, 0x73, 0x74,
+	0x65, 0x72, 0x12, 0x6f, 0x0a, 0x0a, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x4e, 0x6f, 0x64, 0x65,
+	0x12, 0x1f, 0x2e, 0x68, 0x65, 0x61, 0x64, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x2e, 0x76, 0x31, 0x2e,
+	0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x4e, 0x6f, 0x64, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73,
+	0x74, 0x1a, 0x20, 0x2e, 0x68, 0x65, 0x61, 0x64, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x2e, 0x76, 0x31,
+	0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x4e, 0x6f, 0x64, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f,
+	0x6e, 0x73, 0x65, 0x22, 0x1e, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x18, 0x2a, 0x16, 0x2f, 0x61, 0x70,
+	0x69, 0x2f, 0x76, 0x31, 0x2f, 0x6e, 0x6f, 0x64, 0x65, 0x2f, 0x7b, 0x6e, 0x6f, 0x64, 0x65, 0x5f,
+	0x69, 0x64, 0x7d, 0x12, 0x76, 0x0a, 0x0a, 0x45, 0x78, 0x70, 0x69, 0x72, 0x65, 0x4e, 0x6f, 0x64,
+	0x65, 0x12, 0x1f, 0x2e, 0x68, 0x65, 0x61, 0x64, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x2e, 0x76, 0x31,
+	0x2e, 0x45, 0x78, 0x70, 0x69, 0x72, 0x65, 0x4e, 0x6f, 0x64, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65,
+	0x73, 0x74, 0x1a, 0x20, 0x2e, 0x68, 0x65, 0x61, 0x64, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x2e, 0x76,
+	0x31, 0x2e, 0x45, 0x78, 0x70, 0x69, 0x72, 0x65, 0x4e, 0x6f, 0x64, 0x65, 0x52, 0x65, 0x73, 0x70,
+	0x6f, 0x6e, 0x73, 0x65, 0x22, 0x25, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1f, 0x22, 0x1d, 0x2f, 0x61,
+	0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x6e, 0x6f, 0x64, 0x65, 0x2f, 0x7b, 0x6e, 0x6f, 0x64, 0x65,
+	0x5f, 0x69, 0x64, 0x7d, 0x2f, 0x65, 0x78, 0x70, 0x69, 0x72, 0x65, 0x12, 0x81, 0x01, 0x0a, 0x0a,
+	0x52, 0x65, 0x6e, 0x61, 0x6d, 0x65, 0x4e, 0x6f, 0x64, 0x65, 0x12, 0x1f, 0x2e, 0x68, 0x65, 0x61,
+	0x64, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x6e, 0x61, 0x6d, 0x65,
+	0x4e, 0x6f, 0x64, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x20, 0x2e, 0x68, 0x65,
+	0x61, 0x64, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x6e, 0x61, 0x6d,
+	0x65, 0x4e, 0x6f, 0x64, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x30, 0x82,
+	0xd3, 0xe4, 0x93, 0x02, 0x2a, 0x22, 0x28, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x6e,
+	0x6f, 0x64, 0x65, 0x2f, 0x7b, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x69, 0x64, 0x7d, 0x2f, 0x72, 0x65,
 	0x6e, 0x61, 0x6d, 0x65, 0x2f, 0x7b, 0x6e, 0x65, 0x77, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x7d, 0x12,
-	0x6e, 0x0a, 0x0c, 0x4c, 0x69, 0x73, 0x74, 0x4d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x73, 0x12,
-	0x21, 0x2e, 0x68, 0x65, 0x61, 0x64, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x4c,
-	0x69, 0x73, 0x74, 0x4d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65,
-	0x73, 0x74, 0x1a, 0x22, 0x2e, 0x68, 0x65, 0x61, 0x64, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x2e, 0x76,
-	0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x4d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x73, 0x52, 0x65,
-	0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x17, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x11, 0x12, 0x0f,
-	0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x6d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x12,
-	0x7d, 0x0a, 0x0b, 0x4d, 0x6f, 0x76, 0x65, 0x4d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x12, 0x20,
+	0x62, 0x0a, 0x09, 0x4c, 0x69, 0x73, 0x74, 0x4e, 0x6f, 0x64, 0x65, 0x73, 0x12, 0x1e, 0x2e, 0x68,
+	0x65, 0x61, 0x64, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74,
+	0x4e, 0x6f, 0x64, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1f, 0x2e, 0x68,
+	0x65, 0x61, 0x64, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74,
+	0x4e, 0x6f, 0x64, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x14, 0x82,
+	0xd3, 0xe4, 0x93, 0x02, 0x0e, 0x12, 0x0c, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x6e,
+	0x6f, 0x64, 0x65, 0x12, 0x6e, 0x0a, 0x08, 0x4d, 0x6f, 0x76, 0x65, 0x4e, 0x6f, 0x64, 0x65, 0x12,
+	0x1d, 0x2e, 0x68, 0x65, 0x61, 0x64, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x4d,
+	0x6f, 0x76, 0x65, 0x4e, 0x6f, 0x64, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1e,
 	0x2e, 0x68, 0x65, 0x61, 0x64, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x4d, 0x6f,
-	0x76, 0x65, 0x4d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74,
-	0x1a, 0x21, 0x2e, 0x68, 0x65, 0x61, 0x64, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x2e, 0x76, 0x31, 0x2e,
-	0x4d, 0x6f, 0x76, 0x65, 0x4d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f,
-	0x6e, 0x73, 0x65, 0x22, 0x29, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x23, 0x22, 0x21, 0x2f, 0x61, 0x70,
-	0x69, 0x2f, 0x76, 0x31, 0x2f, 0x6d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x2f, 0x7b, 0x6d, 0x61,
-	0x63, 0x68, 0x69, 0x6e, 0x65, 0x5f, 0x69, 0x64, 0x7d, 0x2f, 0x75, 0x73, 0x65, 0x72, 0x12, 0x64,
-	0x0a, 0x09, 0x47, 0x65, 0x74, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x73, 0x12, 0x1e, 0x2e, 0x68, 0x65,
-	0x61, 0x64, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x52, 0x6f,
-	0x75, 0x74, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1f, 0x2e, 0x68, 0x65,
-	0x61, 0x64, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x52, 0x6f,
-	0x75, 0x74, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x16, 0x82, 0xd3,
-	0xe4, 0x93, 0x02, 0x10, 0x12, 0x0e, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x72, 0x6f,
-	0x75, 0x74, 0x65, 0x73, 0x12, 0x7c, 0x0a, 0x0b, 0x45, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x52, 0x6f,
-	0x75, 0x74, 0x65, 0x12, 0x20, 0x2e, 0x68, 0x65, 0x61, 0x64, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x2e,
-	0x76, 0x31, 0x2e, 0x45, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x52, 0x65,
-	0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x21, 0x2e, 0x68, 0x65, 0x61, 0x64, 0x73, 0x63, 0x61, 0x6c,
-	0x65, 0x2e, 0x76, 0x31, 0x2e, 0x45, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x52, 0x6f, 0x75, 0x74, 0x65,
-	0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x28, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x22,
-	0x22, 0x20, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x73,
-	0x2f, 0x7b, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x5f, 0x69, 0x64, 0x7d, 0x2f, 0x65, 0x6e, 0x61, 0x62,
-	0x6c, 0x65, 0x12, 0x80, 0x01, 0x0a, 0x0c, 0x44, 0x69, 0x73, 0x61, 0x62, 0x6c, 0x65, 0x52, 0x6f,
-	0x75, 0x74, 0x65, 0x12, 0x21, 0x2e, 0x68, 0x65, 0x61, 0x64, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x2e,
-	0x76, 0x31, 0x2e, 0x44, 0x69, 0x73, 0x61, 0x62, 0x6c, 0x65, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x52,
-	0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x22, 0x2e, 0x68, 0x65, 0x61, 0x64, 0x73, 0x63, 0x61,
-	0x6c, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x69, 0x73, 0x61, 0x62, 0x6c, 0x65, 0x52, 0x6f, 0x75,
-	0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x29, 0x82, 0xd3, 0xe4, 0x93,
-	0x02, 0x23, 0x22, 0x21, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x72, 0x6f, 0x75, 0x74,
-	0x65, 0x73, 0x2f, 0x7b, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x5f, 0x69, 0x64, 0x7d, 0x2f, 0x64, 0x69,
-	0x73, 0x61, 0x62, 0x6c, 0x65, 0x12, 0x8e, 0x01, 0x0a, 0x10, 0x47, 0x65, 0x74, 0x4d, 0x61, 0x63,
-	0x68, 0x69, 0x6e, 0x65, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x73, 0x12, 0x25, 0x2e, 0x68, 0x65, 0x61,
-	0x64, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x4d, 0x61, 0x63,
-	0x68, 0x69, 0x6e, 0x65, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73,
-	0x74, 0x1a, 0x26, 0x2e, 0x68, 0x65, 0x61, 0x64, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x2e, 0x76, 0x31,
-	0x2e, 0x47, 0x65, 0x74, 0x4d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x52, 0x6f, 0x75, 0x74, 0x65,
-	0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x2b, 0x82, 0xd3, 0xe4, 0x93, 0x02,
-	0x25, 0x12, 0x23, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x6d, 0x61, 0x63, 0x68, 0x69,
-	0x6e, 0x65, 0x2f, 0x7b, 0x6d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x5f, 0x69, 0x64, 0x7d, 0x2f,
-	0x72, 0x6f, 0x75, 0x74, 0x65, 0x73, 0x12, 0x75, 0x0a, 0x0b, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65,
-	0x52, 0x6f, 0x75, 0x74, 0x65, 0x12, 0x20, 0x2e, 0x68, 0x65, 0x61, 0x64, 0x73, 0x63, 0x61, 0x6c,
-	0x65, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x52, 0x6f, 0x75, 0x74, 0x65,
-	0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x21, 0x2e, 0x68, 0x65, 0x61, 0x64, 0x73, 0x63,
-	0x61, 0x6c, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x52, 0x6f, 0x75,
-	0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x21, 0x82, 0xd3, 0xe4, 0x93,
-	0x02, 0x1b, 0x2a, 0x19, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x72, 0x6f, 0x75, 0x74,
-	0x65, 0x73, 0x2f, 0x7b, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x5f, 0x69, 0x64, 0x7d, 0x12, 0x70, 0x0a,
-	0x0c, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x41, 0x70, 0x69, 0x4b, 0x65, 0x79, 0x12, 0x21, 0x2e,
-	0x68, 0x65, 0x61, 0x64, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x72, 0x65,
-	0x61, 0x74, 0x65, 0x41, 0x70, 0x69, 0x4b, 0x65, 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74,
-	0x1a, 0x22, 0x2e, 0x68, 0x65, 0x61, 0x64, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x2e, 0x76, 0x31, 0x2e,
-	0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x41, 0x70, 0x69, 0x4b, 0x65, 0x79, 0x52, 0x65, 0x73, 0x70,
-	0x6f, 0x6e, 0x73, 0x65, 0x22, 0x19, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x13, 0x3a, 0x01, 0x2a, 0x22,
-	0x0e, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x61, 0x70, 0x69, 0x6b, 0x65, 0x79, 0x12,
-	0x77, 0x0a, 0x0c, 0x45, 0x78, 0x70, 0x69, 0x72, 0x65, 0x41, 0x70, 0x69, 0x4b, 0x65, 0x79, 0x12,
-	0x21, 0x2e, 0x68, 0x65, 0x61, 0x64, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x45,
-	0x78, 0x70, 0x69, 0x72, 0x65, 0x41, 0x70, 0x69, 0x4b, 0x65, 0x79, 0x52, 0x65, 0x71, 0x75, 0x65,
-	0x73, 0x74, 0x1a, 0x22, 0x2e, 0x68, 0x65, 0x61, 0x64, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x2e, 0x76,
-	0x31, 0x2e, 0x45, 0x78, 0x70, 0x69, 0x72, 0x65, 0x41, 0x70, 0x69, 0x4b, 0x65, 0x79, 0x52, 0x65,
-	0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x20, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1a, 0x3a, 0x01,
-	0x2a, 0x22, 0x15, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x61, 0x70, 0x69, 0x6b, 0x65,
-	0x79, 0x2f, 0x65, 0x78, 0x70, 0x69, 0x72, 0x65, 0x12, 0x6a, 0x0a, 0x0b, 0x4c, 0x69, 0x73, 0x74,
-	0x41, 0x70, 0x69, 0x4b, 0x65, 0x79, 0x73, 0x12, 0x20, 0x2e, 0x68, 0x65, 0x61, 0x64, 0x73, 0x63,
-	0x61, 0x6c, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x41, 0x70, 0x69, 0x4b, 0x65,
-	0x79, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x21, 0x2e, 0x68, 0x65, 0x61, 0x64,
-	0x73, 0x63, 0x61, 0x6c, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x41, 0x70, 0x69,
-	0x4b, 0x65, 0x79, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x16, 0x82, 0xd3,
-	0xe4, 0x93, 0x02, 0x10, 0x12, 0x0e, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x61, 0x70,
-	0x69, 0x6b, 0x65, 0x79, 0x42, 0x29, 0x5a, 0x27, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63,
-	0x6f, 0x6d, 0x2f, 0x6a, 0x75, 0x61, 0x6e, 0x66, 0x6f, 0x6e, 0x74, 0x2f, 0x68, 0x65, 0x61, 0x64,
-	0x73, 0x63, 0x61, 0x6c, 0x65, 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x67, 0x6f, 0x2f, 0x76, 0x31, 0x62,
-	0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
+	0x76, 0x65, 0x4e, 0x6f, 0x64, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x23,
+	0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1d, 0x22, 0x1b, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f,
+	0x6e, 0x6f, 0x64, 0x65, 0x2f, 0x7b, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x69, 0x64, 0x7d, 0x2f, 0x75,
+	0x73, 0x65, 0x72, 0x12, 0x64, 0x0a, 0x09, 0x47, 0x65, 0x74, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x73,
+	0x12, 0x1e, 0x2e, 0x68, 0x65, 0x61, 0x64, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x2e, 0x76, 0x31, 0x2e,
+	0x47, 0x65, 0x74, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74,
+	0x1a, 0x1f, 0x2e, 0x68, 0x65, 0x61, 0x64, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x2e, 0x76, 0x31, 0x2e,
+	0x47, 0x65, 0x74, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73,
+	0x65, 0x22, 0x16, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x10, 0x12, 0x0e, 0x2f, 0x61, 0x70, 0x69, 0x2f,
+	0x76, 0x31, 0x2f, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x73, 0x12, 0x7c, 0x0a, 0x0b, 0x45, 0x6e, 0x61,
+	0x62, 0x6c, 0x65, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x12, 0x20, 0x2e, 0x68, 0x65, 0x61, 0x64, 0x73,
+	0x63, 0x61, 0x6c, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x45, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x52, 0x6f,
+	0x75, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x21, 0x2e, 0x68, 0x65, 0x61,
+	0x64, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x45, 0x6e, 0x61, 0x62, 0x6c, 0x65,
+	0x52, 0x6f, 0x75, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x28, 0x82,
+	0xd3, 0xe4, 0x93, 0x02, 0x22, 0x22, 0x20, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x72,
+	0x6f, 0x75, 0x74, 0x65, 0x73, 0x2f, 0x7b, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x5f, 0x69, 0x64, 0x7d,
+	0x2f, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x12, 0x80, 0x01, 0x0a, 0x0c, 0x44, 0x69, 0x73, 0x61,
+	0x62, 0x6c, 0x65, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x12, 0x21, 0x2e, 0x68, 0x65, 0x61, 0x64, 0x73,
+	0x63, 0x61, 0x6c, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x69, 0x73, 0x61, 0x62, 0x6c, 0x65, 0x52,
+	0x6f, 0x75, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x22, 0x2e, 0x68, 0x65,
+	0x61, 0x64, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x69, 0x73, 0x61, 0x62,
+	0x6c, 0x65, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22,
+	0x29, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x23, 0x22, 0x21, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31,
+	0x2f, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x73, 0x2f, 0x7b, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x5f, 0x69,
+	0x64, 0x7d, 0x2f, 0x64, 0x69, 0x73, 0x61, 0x62, 0x6c, 0x65, 0x12, 0x7f, 0x0a, 0x0d, 0x47, 0x65,
+	0x74, 0x4e, 0x6f, 0x64, 0x65, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x73, 0x12, 0x22, 0x2e, 0x68, 0x65,
+	0x61, 0x64, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x4e, 0x6f,
+	0x64, 0x65, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a,
+	0x23, 0x2e, 0x68, 0x65, 0x61, 0x64, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x47,
+	0x65, 0x74, 0x4e, 0x6f, 0x64, 0x65, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70,
+	0x6f, 0x6e, 0x73, 0x65, 0x22, 0x25, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1f, 0x12, 0x1d, 0x2f, 0x61,
+	0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x6e, 0x6f, 0x64, 0x65, 0x2f, 0x7b, 0x6e, 0x6f, 0x64, 0x65,
+	0x5f, 0x69, 0x64, 0x7d, 0x2f, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x73, 0x12, 0x75, 0x0a, 0x0b, 0x44,
+	0x65, 0x6c, 0x65, 0x74, 0x65, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x12, 0x20, 0x2e, 0x68, 0x65, 0x61,
+	0x64, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65,
+	0x52, 0x6f, 0x75, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x21, 0x2e, 0x68,
+	0x65, 0x61, 0x64, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65, 0x6c, 0x65,
+	0x74, 0x65, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22,
+	0x21, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1b, 0x2a, 0x19, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31,
+	0x2f, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x73, 0x2f, 0x7b, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x5f, 0x69,
+	0x64, 0x7d, 0x12, 0x70, 0x0a, 0x0c, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x41, 0x70, 0x69, 0x4b,
+	0x65, 0x79, 0x12, 0x21, 0x2e, 0x68, 0x65, 0x61, 0x64, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x2e, 0x76,
+	0x31, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x41, 0x70, 0x69, 0x4b, 0x65, 0x79, 0x52, 0x65,
+	0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x22, 0x2e, 0x68, 0x65, 0x61, 0x64, 0x73, 0x63, 0x61, 0x6c,
+	0x65, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x41, 0x70, 0x69, 0x4b, 0x65,
+	0x79, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x19, 0x82, 0xd3, 0xe4, 0x93, 0x02,
+	0x13, 0x3a, 0x01, 0x2a, 0x22, 0x0e, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x61, 0x70,
+	0x69, 0x6b, 0x65, 0x79, 0x12, 0x77, 0x0a, 0x0c, 0x45, 0x78, 0x70, 0x69, 0x72, 0x65, 0x41, 0x70,
+	0x69, 0x4b, 0x65, 0x79, 0x12, 0x21, 0x2e, 0x68, 0x65, 0x61, 0x64, 0x73, 0x63, 0x61, 0x6c, 0x65,
+	0x2e, 0x76, 0x31, 0x2e, 0x45, 0x78, 0x70, 0x69, 0x72, 0x65, 0x41, 0x70, 0x69, 0x4b, 0x65, 0x79,
+	0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x22, 0x2e, 0x68, 0x65, 0x61, 0x64, 0x73, 0x63,
+	0x61, 0x6c, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x45, 0x78, 0x70, 0x69, 0x72, 0x65, 0x41, 0x70, 0x69,
+	0x4b, 0x65, 0x79, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x20, 0x82, 0xd3, 0xe4,
+	0x93, 0x02, 0x1a, 0x3a, 0x01, 0x2a, 0x22, 0x15, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f,
+	0x61, 0x70, 0x69, 0x6b, 0x65, 0x79, 0x2f, 0x65, 0x78, 0x70, 0x69, 0x72, 0x65, 0x12, 0x6a, 0x0a,
+	0x0b, 0x4c, 0x69, 0x73, 0x74, 0x41, 0x70, 0x69, 0x4b, 0x65, 0x79, 0x73, 0x12, 0x20, 0x2e, 0x68,
+	0x65, 0x61, 0x64, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74,
+	0x41, 0x70, 0x69, 0x4b, 0x65, 0x79, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x21,
+	0x2e, 0x68, 0x65, 0x61, 0x64, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69,
+	0x73, 0x74, 0x41, 0x70, 0x69, 0x4b, 0x65, 0x79, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73,
+	0x65, 0x22, 0x16, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x10, 0x12, 0x0e, 0x2f, 0x61, 0x70, 0x69, 0x2f,
+	0x76, 0x31, 0x2f, 0x61, 0x70, 0x69, 0x6b, 0x65, 0x79, 0x42, 0x29, 0x5a, 0x27, 0x67, 0x69, 0x74,
+	0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x6a, 0x75, 0x61, 0x6e, 0x66, 0x6f, 0x6e, 0x74,
+	0x2f, 0x68, 0x65, 0x61, 0x64, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x67,
+	0x6f, 0x2f, 0x76, 0x31, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
 }
 
 var file_headscale_v1_headscale_proto_goTypes = []interface{}{
-	(*GetUserRequest)(nil),             // 0: headscale.v1.GetUserRequest
-	(*CreateUserRequest)(nil),          // 1: headscale.v1.CreateUserRequest
-	(*RenameUserRequest)(nil),          // 2: headscale.v1.RenameUserRequest
-	(*DeleteUserRequest)(nil),          // 3: headscale.v1.DeleteUserRequest
-	(*ListUsersRequest)(nil),           // 4: headscale.v1.ListUsersRequest
-	(*CreatePreAuthKeyRequest)(nil),    // 5: headscale.v1.CreatePreAuthKeyRequest
-	(*ExpirePreAuthKeyRequest)(nil),    // 6: headscale.v1.ExpirePreAuthKeyRequest
-	(*ListPreAuthKeysRequest)(nil),     // 7: headscale.v1.ListPreAuthKeysRequest
-	(*DebugCreateMachineRequest)(nil),  // 8: headscale.v1.DebugCreateMachineRequest
-	(*GetMachineRequest)(nil),          // 9: headscale.v1.GetMachineRequest
-	(*SetTagsRequest)(nil),             // 10: headscale.v1.SetTagsRequest
-	(*RegisterMachineRequest)(nil),     // 11: headscale.v1.RegisterMachineRequest
-	(*DeleteMachineRequest)(nil),       // 12: headscale.v1.DeleteMachineRequest
-	(*ExpireMachineRequest)(nil),       // 13: headscale.v1.ExpireMachineRequest
-	(*RenameMachineRequest)(nil),       // 14: headscale.v1.RenameMachineRequest
-	(*ListMachinesRequest)(nil),        // 15: headscale.v1.ListMachinesRequest
-	(*MoveMachineRequest)(nil),         // 16: headscale.v1.MoveMachineRequest
-	(*GetRoutesRequest)(nil),           // 17: headscale.v1.GetRoutesRequest
-	(*EnableRouteRequest)(nil),         // 18: headscale.v1.EnableRouteRequest
-	(*DisableRouteRequest)(nil),        // 19: headscale.v1.DisableRouteRequest
-	(*GetMachineRoutesRequest)(nil),    // 20: headscale.v1.GetMachineRoutesRequest
-	(*DeleteRouteRequest)(nil),         // 21: headscale.v1.DeleteRouteRequest
-	(*CreateApiKeyRequest)(nil),        // 22: headscale.v1.CreateApiKeyRequest
-	(*ExpireApiKeyRequest)(nil),        // 23: headscale.v1.ExpireApiKeyRequest
-	(*ListApiKeysRequest)(nil),         // 24: headscale.v1.ListApiKeysRequest
-	(*GetUserResponse)(nil),            // 25: headscale.v1.GetUserResponse
-	(*CreateUserResponse)(nil),         // 26: headscale.v1.CreateUserResponse
-	(*RenameUserResponse)(nil),         // 27: headscale.v1.RenameUserResponse
-	(*DeleteUserResponse)(nil),         // 28: headscale.v1.DeleteUserResponse
-	(*ListUsersResponse)(nil),          // 29: headscale.v1.ListUsersResponse
-	(*CreatePreAuthKeyResponse)(nil),   // 30: headscale.v1.CreatePreAuthKeyResponse
-	(*ExpirePreAuthKeyResponse)(nil),   // 31: headscale.v1.ExpirePreAuthKeyResponse
-	(*ListPreAuthKeysResponse)(nil),    // 32: headscale.v1.ListPreAuthKeysResponse
-	(*DebugCreateMachineResponse)(nil), // 33: headscale.v1.DebugCreateMachineResponse
-	(*GetMachineResponse)(nil),         // 34: headscale.v1.GetMachineResponse
-	(*SetTagsResponse)(nil),            // 35: headscale.v1.SetTagsResponse
-	(*RegisterMachineResponse)(nil),    // 36: headscale.v1.RegisterMachineResponse
-	(*DeleteMachineResponse)(nil),      // 37: headscale.v1.DeleteMachineResponse
-	(*ExpireMachineResponse)(nil),      // 38: headscale.v1.ExpireMachineResponse
-	(*RenameMachineResponse)(nil),      // 39: headscale.v1.RenameMachineResponse
-	(*ListMachinesResponse)(nil),       // 40: headscale.v1.ListMachinesResponse
-	(*MoveMachineResponse)(nil),        // 41: headscale.v1.MoveMachineResponse
-	(*GetRoutesResponse)(nil),          // 42: headscale.v1.GetRoutesResponse
-	(*EnableRouteResponse)(nil),        // 43: headscale.v1.EnableRouteResponse
-	(*DisableRouteResponse)(nil),       // 44: headscale.v1.DisableRouteResponse
-	(*GetMachineRoutesResponse)(nil),   // 45: headscale.v1.GetMachineRoutesResponse
-	(*DeleteRouteResponse)(nil),        // 46: headscale.v1.DeleteRouteResponse
-	(*CreateApiKeyResponse)(nil),       // 47: headscale.v1.CreateApiKeyResponse
-	(*ExpireApiKeyResponse)(nil),       // 48: headscale.v1.ExpireApiKeyResponse
-	(*ListApiKeysResponse)(nil),        // 49: headscale.v1.ListApiKeysResponse
+	(*GetUserRequest)(nil),           // 0: headscale.v1.GetUserRequest
+	(*CreateUserRequest)(nil),        // 1: headscale.v1.CreateUserRequest
+	(*RenameUserRequest)(nil),        // 2: headscale.v1.RenameUserRequest
+	(*DeleteUserRequest)(nil),        // 3: headscale.v1.DeleteUserRequest
+	(*ListUsersRequest)(nil),         // 4: headscale.v1.ListUsersRequest
+	(*CreatePreAuthKeyRequest)(nil),  // 5: headscale.v1.CreatePreAuthKeyRequest
+	(*ExpirePreAuthKeyRequest)(nil),  // 6: headscale.v1.ExpirePreAuthKeyRequest
+	(*ListPreAuthKeysRequest)(nil),   // 7: headscale.v1.ListPreAuthKeysRequest
+	(*DebugCreateNodeRequest)(nil),   // 8: headscale.v1.DebugCreateNodeRequest
+	(*GetNodeRequest)(nil),           // 9: headscale.v1.GetNodeRequest
+	(*SetTagsRequest)(nil),           // 10: headscale.v1.SetTagsRequest
+	(*RegisterNodeRequest)(nil),      // 11: headscale.v1.RegisterNodeRequest
+	(*DeleteNodeRequest)(nil),        // 12: headscale.v1.DeleteNodeRequest
+	(*ExpireNodeRequest)(nil),        // 13: headscale.v1.ExpireNodeRequest
+	(*RenameNodeRequest)(nil),        // 14: headscale.v1.RenameNodeRequest
+	(*ListNodesRequest)(nil),         // 15: headscale.v1.ListNodesRequest
+	(*MoveNodeRequest)(nil),          // 16: headscale.v1.MoveNodeRequest
+	(*GetRoutesRequest)(nil),         // 17: headscale.v1.GetRoutesRequest
+	(*EnableRouteRequest)(nil),       // 18: headscale.v1.EnableRouteRequest
+	(*DisableRouteRequest)(nil),      // 19: headscale.v1.DisableRouteRequest
+	(*GetNodeRoutesRequest)(nil),     // 20: headscale.v1.GetNodeRoutesRequest
+	(*DeleteRouteRequest)(nil),       // 21: headscale.v1.DeleteRouteRequest
+	(*CreateApiKeyRequest)(nil),      // 22: headscale.v1.CreateApiKeyRequest
+	(*ExpireApiKeyRequest)(nil),      // 23: headscale.v1.ExpireApiKeyRequest
+	(*ListApiKeysRequest)(nil),       // 24: headscale.v1.ListApiKeysRequest
+	(*GetUserResponse)(nil),          // 25: headscale.v1.GetUserResponse
+	(*CreateUserResponse)(nil),       // 26: headscale.v1.CreateUserResponse
+	(*RenameUserResponse)(nil),       // 27: headscale.v1.RenameUserResponse
+	(*DeleteUserResponse)(nil),       // 28: headscale.v1.DeleteUserResponse
+	(*ListUsersResponse)(nil),        // 29: headscale.v1.ListUsersResponse
+	(*CreatePreAuthKeyResponse)(nil), // 30: headscale.v1.CreatePreAuthKeyResponse
+	(*ExpirePreAuthKeyResponse)(nil), // 31: headscale.v1.ExpirePreAuthKeyResponse
+	(*ListPreAuthKeysResponse)(nil),  // 32: headscale.v1.ListPreAuthKeysResponse
+	(*DebugCreateNodeResponse)(nil),  // 33: headscale.v1.DebugCreateNodeResponse
+	(*GetNodeResponse)(nil),          // 34: headscale.v1.GetNodeResponse
+	(*SetTagsResponse)(nil),          // 35: headscale.v1.SetTagsResponse
+	(*RegisterNodeResponse)(nil),     // 36: headscale.v1.RegisterNodeResponse
+	(*DeleteNodeResponse)(nil),       // 37: headscale.v1.DeleteNodeResponse
+	(*ExpireNodeResponse)(nil),       // 38: headscale.v1.ExpireNodeResponse
+	(*RenameNodeResponse)(nil),       // 39: headscale.v1.RenameNodeResponse
+	(*ListNodesResponse)(nil),        // 40: headscale.v1.ListNodesResponse
+	(*MoveNodeResponse)(nil),         // 41: headscale.v1.MoveNodeResponse
+	(*GetRoutesResponse)(nil),        // 42: headscale.v1.GetRoutesResponse
+	(*EnableRouteResponse)(nil),      // 43: headscale.v1.EnableRouteResponse
+	(*DisableRouteResponse)(nil),     // 44: headscale.v1.DisableRouteResponse
+	(*GetNodeRoutesResponse)(nil),    // 45: headscale.v1.GetNodeRoutesResponse
+	(*DeleteRouteResponse)(nil),      // 46: headscale.v1.DeleteRouteResponse
+	(*CreateApiKeyResponse)(nil),     // 47: headscale.v1.CreateApiKeyResponse
+	(*ExpireApiKeyResponse)(nil),     // 48: headscale.v1.ExpireApiKeyResponse
+	(*ListApiKeysResponse)(nil),      // 49: headscale.v1.ListApiKeysResponse
 }
 var file_headscale_v1_headscale_proto_depIdxs = []int32{
 	0,  // 0: headscale.v1.HeadscaleService.GetUser:input_type -> headscale.v1.GetUserRequest
@@ -296,19 +287,19 @@ var file_headscale_v1_headscale_proto_depIdxs = []int32{
 	5,  // 5: headscale.v1.HeadscaleService.CreatePreAuthKey:input_type -> headscale.v1.CreatePreAuthKeyRequest
 	6,  // 6: headscale.v1.HeadscaleService.ExpirePreAuthKey:input_type -> headscale.v1.ExpirePreAuthKeyRequest
 	7,  // 7: headscale.v1.HeadscaleService.ListPreAuthKeys:input_type -> headscale.v1.ListPreAuthKeysRequest
-	8,  // 8: headscale.v1.HeadscaleService.DebugCreateMachine:input_type -> headscale.v1.DebugCreateMachineRequest
-	9,  // 9: headscale.v1.HeadscaleService.GetMachine:input_type -> headscale.v1.GetMachineRequest
+	8,  // 8: headscale.v1.HeadscaleService.DebugCreateNode:input_type -> headscale.v1.DebugCreateNodeRequest
+	9,  // 9: headscale.v1.HeadscaleService.GetNode:input_type -> headscale.v1.GetNodeRequest
 	10, // 10: headscale.v1.HeadscaleService.SetTags:input_type -> headscale.v1.SetTagsRequest
-	11, // 11: headscale.v1.HeadscaleService.RegisterMachine:input_type -> headscale.v1.RegisterMachineRequest
-	12, // 12: headscale.v1.HeadscaleService.DeleteMachine:input_type -> headscale.v1.DeleteMachineRequest
-	13, // 13: headscale.v1.HeadscaleService.ExpireMachine:input_type -> headscale.v1.ExpireMachineRequest
-	14, // 14: headscale.v1.HeadscaleService.RenameMachine:input_type -> headscale.v1.RenameMachineRequest
-	15, // 15: headscale.v1.HeadscaleService.ListMachines:input_type -> headscale.v1.ListMachinesRequest
-	16, // 16: headscale.v1.HeadscaleService.MoveMachine:input_type -> headscale.v1.MoveMachineRequest
+	11, // 11: headscale.v1.HeadscaleService.RegisterNode:input_type -> headscale.v1.RegisterNodeRequest
+	12, // 12: headscale.v1.HeadscaleService.DeleteNode:input_type -> headscale.v1.DeleteNodeRequest
+	13, // 13: headscale.v1.HeadscaleService.ExpireNode:input_type -> headscale.v1.ExpireNodeRequest
+	14, // 14: headscale.v1.HeadscaleService.RenameNode:input_type -> headscale.v1.RenameNodeRequest
+	15, // 15: headscale.v1.HeadscaleService.ListNodes:input_type -> headscale.v1.ListNodesRequest
+	16, // 16: headscale.v1.HeadscaleService.MoveNode:input_type -> headscale.v1.MoveNodeRequest
 	17, // 17: headscale.v1.HeadscaleService.GetRoutes:input_type -> headscale.v1.GetRoutesRequest
 	18, // 18: headscale.v1.HeadscaleService.EnableRoute:input_type -> headscale.v1.EnableRouteRequest
 	19, // 19: headscale.v1.HeadscaleService.DisableRoute:input_type -> headscale.v1.DisableRouteRequest
-	20, // 20: headscale.v1.HeadscaleService.GetMachineRoutes:input_type -> headscale.v1.GetMachineRoutesRequest
+	20, // 20: headscale.v1.HeadscaleService.GetNodeRoutes:input_type -> headscale.v1.GetNodeRoutesRequest
 	21, // 21: headscale.v1.HeadscaleService.DeleteRoute:input_type -> headscale.v1.DeleteRouteRequest
 	22, // 22: headscale.v1.HeadscaleService.CreateApiKey:input_type -> headscale.v1.CreateApiKeyRequest
 	23, // 23: headscale.v1.HeadscaleService.ExpireApiKey:input_type -> headscale.v1.ExpireApiKeyRequest
@@ -321,19 +312,19 @@ var file_headscale_v1_headscale_proto_depIdxs = []int32{
 	30, // 30: headscale.v1.HeadscaleService.CreatePreAuthKey:output_type -> headscale.v1.CreatePreAuthKeyResponse
 	31, // 31: headscale.v1.HeadscaleService.ExpirePreAuthKey:output_type -> headscale.v1.ExpirePreAuthKeyResponse
 	32, // 32: headscale.v1.HeadscaleService.ListPreAuthKeys:output_type -> headscale.v1.ListPreAuthKeysResponse
-	33, // 33: headscale.v1.HeadscaleService.DebugCreateMachine:output_type -> headscale.v1.DebugCreateMachineResponse
-	34, // 34: headscale.v1.HeadscaleService.GetMachine:output_type -> headscale.v1.GetMachineResponse
+	33, // 33: headscale.v1.HeadscaleService.DebugCreateNode:output_type -> headscale.v1.DebugCreateNodeResponse
+	34, // 34: headscale.v1.HeadscaleService.GetNode:output_type -> headscale.v1.GetNodeResponse
 	35, // 35: headscale.v1.HeadscaleService.SetTags:output_type -> headscale.v1.SetTagsResponse
-	36, // 36: headscale.v1.HeadscaleService.RegisterMachine:output_type -> headscale.v1.RegisterMachineResponse
-	37, // 37: headscale.v1.HeadscaleService.DeleteMachine:output_type -> headscale.v1.DeleteMachineResponse
-	38, // 38: headscale.v1.HeadscaleService.ExpireMachine:output_type -> headscale.v1.ExpireMachineResponse
-	39, // 39: headscale.v1.HeadscaleService.RenameMachine:output_type -> headscale.v1.RenameMachineResponse
-	40, // 40: headscale.v1.HeadscaleService.ListMachines:output_type -> headscale.v1.ListMachinesResponse
-	41, // 41: headscale.v1.HeadscaleService.MoveMachine:output_type -> headscale.v1.MoveMachineResponse
+	36, // 36: headscale.v1.HeadscaleService.RegisterNode:output_type -> headscale.v1.RegisterNodeResponse
+	37, // 37: headscale.v1.HeadscaleService.DeleteNode:output_type -> headscale.v1.DeleteNodeResponse
+	38, // 38: headscale.v1.HeadscaleService.ExpireNode:output_type -> headscale.v1.ExpireNodeResponse
+	39, // 39: headscale.v1.HeadscaleService.RenameNode:output_type -> headscale.v1.RenameNodeResponse
+	40, // 40: headscale.v1.HeadscaleService.ListNodes:output_type -> headscale.v1.ListNodesResponse
+	41, // 41: headscale.v1.HeadscaleService.MoveNode:output_type -> headscale.v1.MoveNodeResponse
 	42, // 42: headscale.v1.HeadscaleService.GetRoutes:output_type -> headscale.v1.GetRoutesResponse
 	43, // 43: headscale.v1.HeadscaleService.EnableRoute:output_type -> headscale.v1.EnableRouteResponse
 	44, // 44: headscale.v1.HeadscaleService.DisableRoute:output_type -> headscale.v1.DisableRouteResponse
-	45, // 45: headscale.v1.HeadscaleService.GetMachineRoutes:output_type -> headscale.v1.GetMachineRoutesResponse
+	45, // 45: headscale.v1.HeadscaleService.GetNodeRoutes:output_type -> headscale.v1.GetNodeRoutesResponse
 	46, // 46: headscale.v1.HeadscaleService.DeleteRoute:output_type -> headscale.v1.DeleteRouteResponse
 	47, // 47: headscale.v1.HeadscaleService.CreateApiKey:output_type -> headscale.v1.CreateApiKeyResponse
 	48, // 48: headscale.v1.HeadscaleService.ExpireApiKey:output_type -> headscale.v1.ExpireApiKeyResponse
@@ -352,7 +343,7 @@ func file_headscale_v1_headscale_proto_init() {
 	}
 	file_headscale_v1_user_proto_init()
 	file_headscale_v1_preauthkey_proto_init()
-	file_headscale_v1_machine_proto_init()
+	file_headscale_v1_node_proto_init()
 	file_headscale_v1_routes_proto_init()
 	file_headscale_v1_apikey_proto_init()
 	type x struct{}
diff --git a/gen/go/headscale/v1/headscale.pb.gw.go b/gen/go/headscale/v1/headscale.pb.gw.go
index 4ee9fd4f42..6acf8fc39b 100644
--- a/gen/go/headscale/v1/headscale.pb.gw.go
+++ b/gen/go/headscale/v1/headscale.pb.gw.go
@@ -363,8 +363,8 @@ func local_request_HeadscaleService_ListPreAuthKeys_0(ctx context.Context, marsh
 
 }
 
-func request_HeadscaleService_DebugCreateMachine_0(ctx context.Context, marshaler runtime.Marshaler, client HeadscaleServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
-	var protoReq DebugCreateMachineRequest
+func request_HeadscaleService_DebugCreateNode_0(ctx context.Context, marshaler runtime.Marshaler, client HeadscaleServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq DebugCreateNodeRequest
 	var metadata runtime.ServerMetadata
 
 	newReader, berr := utilities.IOReaderFactory(req.Body)
@@ -375,13 +375,13 @@ func request_HeadscaleService_DebugCreateMachine_0(ctx context.Context, marshale
 		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
 	}
 
-	msg, err := client.DebugCreateMachine(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
+	msg, err := client.DebugCreateNode(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
 	return msg, metadata, err
 
 }
 
-func local_request_HeadscaleService_DebugCreateMachine_0(ctx context.Context, marshaler runtime.Marshaler, server HeadscaleServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
-	var protoReq DebugCreateMachineRequest
+func local_request_HeadscaleService_DebugCreateNode_0(ctx context.Context, marshaler runtime.Marshaler, server HeadscaleServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq DebugCreateNodeRequest
 	var metadata runtime.ServerMetadata
 
 	newReader, berr := utilities.IOReaderFactory(req.Body)
@@ -392,13 +392,13 @@ func local_request_HeadscaleService_DebugCreateMachine_0(ctx context.Context, ma
 		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
 	}
 
-	msg, err := server.DebugCreateMachine(ctx, &protoReq)
+	msg, err := server.DebugCreateNode(ctx, &protoReq)
 	return msg, metadata, err
 
 }
 
-func request_HeadscaleService_GetMachine_0(ctx context.Context, marshaler runtime.Marshaler, client HeadscaleServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
-	var protoReq GetMachineRequest
+func request_HeadscaleService_GetNode_0(ctx context.Context, marshaler runtime.Marshaler, client HeadscaleServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq GetNodeRequest
 	var metadata runtime.ServerMetadata
 
 	var (
@@ -408,23 +408,23 @@ func request_HeadscaleService_GetMachine_0(ctx context.Context, marshaler runtim
 		_   = err
 	)
 
-	val, ok = pathParams["machine_id"]
+	val, ok = pathParams["node_id"]
 	if !ok {
-		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "machine_id")
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "node_id")
 	}
 
-	protoReq.MachineId, err = runtime.Uint64(val)
+	protoReq.NodeId, err = runtime.Uint64(val)
 	if err != nil {
-		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "machine_id", err)
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "node_id", err)
 	}
 
-	msg, err := client.GetMachine(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
+	msg, err := client.GetNode(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
 	return msg, metadata, err
 
 }
 
-func local_request_HeadscaleService_GetMachine_0(ctx context.Context, marshaler runtime.Marshaler, server HeadscaleServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
-	var protoReq GetMachineRequest
+func local_request_HeadscaleService_GetNode_0(ctx context.Context, marshaler runtime.Marshaler, server HeadscaleServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq GetNodeRequest
 	var metadata runtime.ServerMetadata
 
 	var (
@@ -434,17 +434,17 @@ func local_request_HeadscaleService_GetMachine_0(ctx context.Context, marshaler
 		_   = err
 	)
 
-	val, ok = pathParams["machine_id"]
+	val, ok = pathParams["node_id"]
 	if !ok {
-		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "machine_id")
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "node_id")
 	}
 
-	protoReq.MachineId, err = runtime.Uint64(val)
+	protoReq.NodeId, err = runtime.Uint64(val)
 	if err != nil {
-		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "machine_id", err)
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "node_id", err)
 	}
 
-	msg, err := server.GetMachine(ctx, &protoReq)
+	msg, err := server.GetNode(ctx, &protoReq)
 	return msg, metadata, err
 
 }
@@ -468,14 +468,14 @@ func request_HeadscaleService_SetTags_0(ctx context.Context, marshaler runtime.M
 		_   = err
 	)
 
-	val, ok = pathParams["machine_id"]
+	val, ok = pathParams["node_id"]
 	if !ok {
-		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "machine_id")
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "node_id")
 	}
 
-	protoReq.MachineId, err = runtime.Uint64(val)
+	protoReq.NodeId, err = runtime.Uint64(val)
 	if err != nil {
-		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "machine_id", err)
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "node_id", err)
 	}
 
 	msg, err := client.SetTags(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
@@ -502,14 +502,14 @@ func local_request_HeadscaleService_SetTags_0(ctx context.Context, marshaler run
 		_   = err
 	)
 
-	val, ok = pathParams["machine_id"]
+	val, ok = pathParams["node_id"]
 	if !ok {
-		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "machine_id")
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "node_id")
 	}
 
-	protoReq.MachineId, err = runtime.Uint64(val)
+	protoReq.NodeId, err = runtime.Uint64(val)
 	if err != nil {
-		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "machine_id", err)
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "node_id", err)
 	}
 
 	msg, err := server.SetTags(ctx, &protoReq)
@@ -518,43 +518,43 @@ func local_request_HeadscaleService_SetTags_0(ctx context.Context, marshaler run
 }
 
 var (
-	filter_HeadscaleService_RegisterMachine_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)}
+	filter_HeadscaleService_RegisterNode_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)}
 )
 
-func request_HeadscaleService_RegisterMachine_0(ctx context.Context, marshaler runtime.Marshaler, client HeadscaleServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
-	var protoReq RegisterMachineRequest
+func request_HeadscaleService_RegisterNode_0(ctx context.Context, marshaler runtime.Marshaler, client HeadscaleServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq RegisterNodeRequest
 	var metadata runtime.ServerMetadata
 
 	if err := req.ParseForm(); err != nil {
 		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
 	}
-	if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_HeadscaleService_RegisterMachine_0); err != nil {
+	if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_HeadscaleService_RegisterNode_0); err != nil {
 		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
 	}
 
-	msg, err := client.RegisterMachine(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
+	msg, err := client.RegisterNode(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
 	return msg, metadata, err
 
 }
 
-func local_request_HeadscaleService_RegisterMachine_0(ctx context.Context, marshaler runtime.Marshaler, server HeadscaleServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
-	var protoReq RegisterMachineRequest
+func local_request_HeadscaleService_RegisterNode_0(ctx context.Context, marshaler runtime.Marshaler, server HeadscaleServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq RegisterNodeRequest
 	var metadata runtime.ServerMetadata
 
 	if err := req.ParseForm(); err != nil {
 		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
 	}
-	if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_HeadscaleService_RegisterMachine_0); err != nil {
+	if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_HeadscaleService_RegisterNode_0); err != nil {
 		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
 	}
 
-	msg, err := server.RegisterMachine(ctx, &protoReq)
+	msg, err := server.RegisterNode(ctx, &protoReq)
 	return msg, metadata, err
 
 }
 
-func request_HeadscaleService_DeleteMachine_0(ctx context.Context, marshaler runtime.Marshaler, client HeadscaleServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
-	var protoReq DeleteMachineRequest
+func request_HeadscaleService_DeleteNode_0(ctx context.Context, marshaler runtime.Marshaler, client HeadscaleServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq DeleteNodeRequest
 	var metadata runtime.ServerMetadata
 
 	var (
@@ -564,23 +564,23 @@ func request_HeadscaleService_DeleteMachine_0(ctx context.Context, marshaler run
 		_   = err
 	)
 
-	val, ok = pathParams["machine_id"]
+	val, ok = pathParams["node_id"]
 	if !ok {
-		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "machine_id")
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "node_id")
 	}
 
-	protoReq.MachineId, err = runtime.Uint64(val)
+	protoReq.NodeId, err = runtime.Uint64(val)
 	if err != nil {
-		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "machine_id", err)
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "node_id", err)
 	}
 
-	msg, err := client.DeleteMachine(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
+	msg, err := client.DeleteNode(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
 	return msg, metadata, err
 
 }
 
-func local_request_HeadscaleService_DeleteMachine_0(ctx context.Context, marshaler runtime.Marshaler, server HeadscaleServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
-	var protoReq DeleteMachineRequest
+func local_request_HeadscaleService_DeleteNode_0(ctx context.Context, marshaler runtime.Marshaler, server HeadscaleServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq DeleteNodeRequest
 	var metadata runtime.ServerMetadata
 
 	var (
@@ -590,23 +590,23 @@ func local_request_HeadscaleService_DeleteMachine_0(ctx context.Context, marshal
 		_   = err
 	)
 
-	val, ok = pathParams["machine_id"]
+	val, ok = pathParams["node_id"]
 	if !ok {
-		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "machine_id")
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "node_id")
 	}
 
-	protoReq.MachineId, err = runtime.Uint64(val)
+	protoReq.NodeId, err = runtime.Uint64(val)
 	if err != nil {
-		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "machine_id", err)
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "node_id", err)
 	}
 
-	msg, err := server.DeleteMachine(ctx, &protoReq)
+	msg, err := server.DeleteNode(ctx, &protoReq)
 	return msg, metadata, err
 
 }
 
-func request_HeadscaleService_ExpireMachine_0(ctx context.Context, marshaler runtime.Marshaler, client HeadscaleServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
-	var protoReq ExpireMachineRequest
+func request_HeadscaleService_ExpireNode_0(ctx context.Context, marshaler runtime.Marshaler, client HeadscaleServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq ExpireNodeRequest
 	var metadata runtime.ServerMetadata
 
 	var (
@@ -616,23 +616,23 @@ func request_HeadscaleService_ExpireMachine_0(ctx context.Context, marshaler run
 		_   = err
 	)
 
-	val, ok = pathParams["machine_id"]
+	val, ok = pathParams["node_id"]
 	if !ok {
-		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "machine_id")
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "node_id")
 	}
 
-	protoReq.MachineId, err = runtime.Uint64(val)
+	protoReq.NodeId, err = runtime.Uint64(val)
 	if err != nil {
-		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "machine_id", err)
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "node_id", err)
 	}
 
-	msg, err := client.ExpireMachine(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
+	msg, err := client.ExpireNode(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
 	return msg, metadata, err
 
 }
 
-func local_request_HeadscaleService_ExpireMachine_0(ctx context.Context, marshaler runtime.Marshaler, server HeadscaleServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
-	var protoReq ExpireMachineRequest
+func local_request_HeadscaleService_ExpireNode_0(ctx context.Context, marshaler runtime.Marshaler, server HeadscaleServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq ExpireNodeRequest
 	var metadata runtime.ServerMetadata
 
 	var (
@@ -642,23 +642,23 @@ func local_request_HeadscaleService_ExpireMachine_0(ctx context.Context, marshal
 		_   = err
 	)
 
-	val, ok = pathParams["machine_id"]
+	val, ok = pathParams["node_id"]
 	if !ok {
-		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "machine_id")
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "node_id")
 	}
 
-	protoReq.MachineId, err = runtime.Uint64(val)
+	protoReq.NodeId, err = runtime.Uint64(val)
 	if err != nil {
-		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "machine_id", err)
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "node_id", err)
 	}
 
-	msg, err := server.ExpireMachine(ctx, &protoReq)
+	msg, err := server.ExpireNode(ctx, &protoReq)
 	return msg, metadata, err
 
 }
 
-func request_HeadscaleService_RenameMachine_0(ctx context.Context, marshaler runtime.Marshaler, client HeadscaleServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
-	var protoReq RenameMachineRequest
+func request_HeadscaleService_RenameNode_0(ctx context.Context, marshaler runtime.Marshaler, client HeadscaleServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq RenameNodeRequest
 	var metadata runtime.ServerMetadata
 
 	var (
@@ -668,14 +668,14 @@ func request_HeadscaleService_RenameMachine_0(ctx context.Context, marshaler run
 		_   = err
 	)
 
-	val, ok = pathParams["machine_id"]
+	val, ok = pathParams["node_id"]
 	if !ok {
-		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "machine_id")
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "node_id")
 	}
 
-	protoReq.MachineId, err = runtime.Uint64(val)
+	protoReq.NodeId, err = runtime.Uint64(val)
 	if err != nil {
-		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "machine_id", err)
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "node_id", err)
 	}
 
 	val, ok = pathParams["new_name"]
@@ -688,13 +688,13 @@ func request_HeadscaleService_RenameMachine_0(ctx context.Context, marshaler run
 		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "new_name", err)
 	}
 
-	msg, err := client.RenameMachine(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
+	msg, err := client.RenameNode(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
 	return msg, metadata, err
 
 }
 
-func local_request_HeadscaleService_RenameMachine_0(ctx context.Context, marshaler runtime.Marshaler, server HeadscaleServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
-	var protoReq RenameMachineRequest
+func local_request_HeadscaleService_RenameNode_0(ctx context.Context, marshaler runtime.Marshaler, server HeadscaleServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq RenameNodeRequest
 	var metadata runtime.ServerMetadata
 
 	var (
@@ -704,14 +704,14 @@ func local_request_HeadscaleService_RenameMachine_0(ctx context.Context, marshal
 		_   = err
 	)
 
-	val, ok = pathParams["machine_id"]
+	val, ok = pathParams["node_id"]
 	if !ok {
-		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "machine_id")
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "node_id")
 	}
 
-	protoReq.MachineId, err = runtime.Uint64(val)
+	protoReq.NodeId, err = runtime.Uint64(val)
 	if err != nil {
-		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "machine_id", err)
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "node_id", err)
 	}
 
 	val, ok = pathParams["new_name"]
@@ -724,53 +724,53 @@ func local_request_HeadscaleService_RenameMachine_0(ctx context.Context, marshal
 		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "new_name", err)
 	}
 
-	msg, err := server.RenameMachine(ctx, &protoReq)
+	msg, err := server.RenameNode(ctx, &protoReq)
 	return msg, metadata, err
 
 }
 
 var (
-	filter_HeadscaleService_ListMachines_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)}
+	filter_HeadscaleService_ListNodes_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)}
 )
 
-func request_HeadscaleService_ListMachines_0(ctx context.Context, marshaler runtime.Marshaler, client HeadscaleServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
-	var protoReq ListMachinesRequest
+func request_HeadscaleService_ListNodes_0(ctx context.Context, marshaler runtime.Marshaler, client HeadscaleServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq ListNodesRequest
 	var metadata runtime.ServerMetadata
 
 	if err := req.ParseForm(); err != nil {
 		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
 	}
-	if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_HeadscaleService_ListMachines_0); err != nil {
+	if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_HeadscaleService_ListNodes_0); err != nil {
 		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
 	}
 
-	msg, err := client.ListMachines(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
+	msg, err := client.ListNodes(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
 	return msg, metadata, err
 
 }
 
-func local_request_HeadscaleService_ListMachines_0(ctx context.Context, marshaler runtime.Marshaler, server HeadscaleServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
-	var protoReq ListMachinesRequest
+func local_request_HeadscaleService_ListNodes_0(ctx context.Context, marshaler runtime.Marshaler, server HeadscaleServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq ListNodesRequest
 	var metadata runtime.ServerMetadata
 
 	if err := req.ParseForm(); err != nil {
 		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
 	}
-	if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_HeadscaleService_ListMachines_0); err != nil {
+	if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_HeadscaleService_ListNodes_0); err != nil {
 		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
 	}
 
-	msg, err := server.ListMachines(ctx, &protoReq)
+	msg, err := server.ListNodes(ctx, &protoReq)
 	return msg, metadata, err
 
 }
 
 var (
-	filter_HeadscaleService_MoveMachine_0 = &utilities.DoubleArray{Encoding: map[string]int{"machine_id": 0}, Base: []int{1, 1, 0}, Check: []int{0, 1, 2}}
+	filter_HeadscaleService_MoveNode_0 = &utilities.DoubleArray{Encoding: map[string]int{"node_id": 0}, Base: []int{1, 1, 0}, Check: []int{0, 1, 2}}
 )
 
-func request_HeadscaleService_MoveMachine_0(ctx context.Context, marshaler runtime.Marshaler, client HeadscaleServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
-	var protoReq MoveMachineRequest
+func request_HeadscaleService_MoveNode_0(ctx context.Context, marshaler runtime.Marshaler, client HeadscaleServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq MoveNodeRequest
 	var metadata runtime.ServerMetadata
 
 	var (
@@ -780,30 +780,30 @@ func request_HeadscaleService_MoveMachine_0(ctx context.Context, marshaler runti
 		_   = err
 	)
 
-	val, ok = pathParams["machine_id"]
+	val, ok = pathParams["node_id"]
 	if !ok {
-		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "machine_id")
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "node_id")
 	}
 
-	protoReq.MachineId, err = runtime.Uint64(val)
+	protoReq.NodeId, err = runtime.Uint64(val)
 	if err != nil {
-		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "machine_id", err)
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "node_id", err)
 	}
 
 	if err := req.ParseForm(); err != nil {
 		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
 	}
-	if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_HeadscaleService_MoveMachine_0); err != nil {
+	if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_HeadscaleService_MoveNode_0); err != nil {
 		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
 	}
 
-	msg, err := client.MoveMachine(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
+	msg, err := client.MoveNode(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
 	return msg, metadata, err
 
 }
 
-func local_request_HeadscaleService_MoveMachine_0(ctx context.Context, marshaler runtime.Marshaler, server HeadscaleServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
-	var protoReq MoveMachineRequest
+func local_request_HeadscaleService_MoveNode_0(ctx context.Context, marshaler runtime.Marshaler, server HeadscaleServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq MoveNodeRequest
 	var metadata runtime.ServerMetadata
 
 	var (
@@ -813,24 +813,24 @@ func local_request_HeadscaleService_MoveMachine_0(ctx context.Context, marshaler
 		_   = err
 	)
 
-	val, ok = pathParams["machine_id"]
+	val, ok = pathParams["node_id"]
 	if !ok {
-		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "machine_id")
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "node_id")
 	}
 
-	protoReq.MachineId, err = runtime.Uint64(val)
+	protoReq.NodeId, err = runtime.Uint64(val)
 	if err != nil {
-		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "machine_id", err)
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "node_id", err)
 	}
 
 	if err := req.ParseForm(); err != nil {
 		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
 	}
-	if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_HeadscaleService_MoveMachine_0); err != nil {
+	if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_HeadscaleService_MoveNode_0); err != nil {
 		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
 	}
 
-	msg, err := server.MoveMachine(ctx, &protoReq)
+	msg, err := server.MoveNode(ctx, &protoReq)
 	return msg, metadata, err
 
 }
@@ -957,8 +957,8 @@ func local_request_HeadscaleService_DisableRoute_0(ctx context.Context, marshale
 
 }
 
-func request_HeadscaleService_GetMachineRoutes_0(ctx context.Context, marshaler runtime.Marshaler, client HeadscaleServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
-	var protoReq GetMachineRoutesRequest
+func request_HeadscaleService_GetNodeRoutes_0(ctx context.Context, marshaler runtime.Marshaler, client HeadscaleServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq GetNodeRoutesRequest
 	var metadata runtime.ServerMetadata
 
 	var (
@@ -968,23 +968,23 @@ func request_HeadscaleService_GetMachineRoutes_0(ctx context.Context, marshaler
 		_   = err
 	)
 
-	val, ok = pathParams["machine_id"]
+	val, ok = pathParams["node_id"]
 	if !ok {
-		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "machine_id")
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "node_id")
 	}
 
-	protoReq.MachineId, err = runtime.Uint64(val)
+	protoReq.NodeId, err = runtime.Uint64(val)
 	if err != nil {
-		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "machine_id", err)
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "node_id", err)
 	}
 
-	msg, err := client.GetMachineRoutes(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
+	msg, err := client.GetNodeRoutes(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
 	return msg, metadata, err
 
 }
 
-func local_request_HeadscaleService_GetMachineRoutes_0(ctx context.Context, marshaler runtime.Marshaler, server HeadscaleServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
-	var protoReq GetMachineRoutesRequest
+func local_request_HeadscaleService_GetNodeRoutes_0(ctx context.Context, marshaler runtime.Marshaler, server HeadscaleServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq GetNodeRoutesRequest
 	var metadata runtime.ServerMetadata
 
 	var (
@@ -994,17 +994,17 @@ func local_request_HeadscaleService_GetMachineRoutes_0(ctx context.Context, mars
 		_   = err
 	)
 
-	val, ok = pathParams["machine_id"]
+	val, ok = pathParams["node_id"]
 	if !ok {
-		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "machine_id")
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "node_id")
 	}
 
-	protoReq.MachineId, err = runtime.Uint64(val)
+	protoReq.NodeId, err = runtime.Uint64(val)
 	if err != nil {
-		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "machine_id", err)
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "node_id", err)
 	}
 
-	msg, err := server.GetMachineRoutes(ctx, &protoReq)
+	msg, err := server.GetNodeRoutes(ctx, &protoReq)
 	return msg, metadata, err
 
 }
@@ -1353,7 +1353,7 @@ func RegisterHeadscaleServiceHandlerServer(ctx context.Context, mux *runtime.Ser
 
 	})
 
-	mux.Handle("POST", pattern_HeadscaleService_DebugCreateMachine_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+	mux.Handle("POST", pattern_HeadscaleService_DebugCreateNode_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
 		ctx, cancel := context.WithCancel(req.Context())
 		defer cancel()
 		var stream runtime.ServerTransportStream
@@ -1361,12 +1361,12 @@ func RegisterHeadscaleServiceHandlerServer(ctx context.Context, mux *runtime.Ser
 		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
 		var err error
 		var annotatedContext context.Context
-		annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/headscale.v1.HeadscaleService/DebugCreateMachine", runtime.WithHTTPPathPattern("/api/v1/debug/machine"))
+		annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/headscale.v1.HeadscaleService/DebugCreateNode", runtime.WithHTTPPathPattern("/api/v1/debug/node"))
 		if err != nil {
 			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
 			return
 		}
-		resp, md, err := local_request_HeadscaleService_DebugCreateMachine_0(annotatedContext, inboundMarshaler, server, req, pathParams)
+		resp, md, err := local_request_HeadscaleService_DebugCreateNode_0(annotatedContext, inboundMarshaler, server, req, pathParams)
 		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
 		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
 		if err != nil {
@@ -1374,11 +1374,11 @@ func RegisterHeadscaleServiceHandlerServer(ctx context.Context, mux *runtime.Ser
 			return
 		}
 
-		forward_HeadscaleService_DebugCreateMachine_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+		forward_HeadscaleService_DebugCreateNode_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
 
 	})
 
-	mux.Handle("GET", pattern_HeadscaleService_GetMachine_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+	mux.Handle("GET", pattern_HeadscaleService_GetNode_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
 		ctx, cancel := context.WithCancel(req.Context())
 		defer cancel()
 		var stream runtime.ServerTransportStream
@@ -1386,12 +1386,12 @@ func RegisterHeadscaleServiceHandlerServer(ctx context.Context, mux *runtime.Ser
 		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
 		var err error
 		var annotatedContext context.Context
-		annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/headscale.v1.HeadscaleService/GetMachine", runtime.WithHTTPPathPattern("/api/v1/machine/{machine_id}"))
+		annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/headscale.v1.HeadscaleService/GetNode", runtime.WithHTTPPathPattern("/api/v1/node/{node_id}"))
 		if err != nil {
 			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
 			return
 		}
-		resp, md, err := local_request_HeadscaleService_GetMachine_0(annotatedContext, inboundMarshaler, server, req, pathParams)
+		resp, md, err := local_request_HeadscaleService_GetNode_0(annotatedContext, inboundMarshaler, server, req, pathParams)
 		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
 		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
 		if err != nil {
@@ -1399,7 +1399,7 @@ func RegisterHeadscaleServiceHandlerServer(ctx context.Context, mux *runtime.Ser
 			return
 		}
 
-		forward_HeadscaleService_GetMachine_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+		forward_HeadscaleService_GetNode_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
 
 	})
 
@@ -1411,7 +1411,7 @@ func RegisterHeadscaleServiceHandlerServer(ctx context.Context, mux *runtime.Ser
 		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
 		var err error
 		var annotatedContext context.Context
-		annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/headscale.v1.HeadscaleService/SetTags", runtime.WithHTTPPathPattern("/api/v1/machine/{machine_id}/tags"))
+		annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/headscale.v1.HeadscaleService/SetTags", runtime.WithHTTPPathPattern("/api/v1/node/{node_id}/tags"))
 		if err != nil {
 			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
 			return
@@ -1428,7 +1428,7 @@ func RegisterHeadscaleServiceHandlerServer(ctx context.Context, mux *runtime.Ser
 
 	})
 
-	mux.Handle("POST", pattern_HeadscaleService_RegisterMachine_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+	mux.Handle("POST", pattern_HeadscaleService_RegisterNode_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
 		ctx, cancel := context.WithCancel(req.Context())
 		defer cancel()
 		var stream runtime.ServerTransportStream
@@ -1436,12 +1436,12 @@ func RegisterHeadscaleServiceHandlerServer(ctx context.Context, mux *runtime.Ser
 		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
 		var err error
 		var annotatedContext context.Context
-		annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/headscale.v1.HeadscaleService/RegisterMachine", runtime.WithHTTPPathPattern("/api/v1/machine/register"))
+		annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/headscale.v1.HeadscaleService/RegisterNode", runtime.WithHTTPPathPattern("/api/v1/node/register"))
 		if err != nil {
 			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
 			return
 		}
-		resp, md, err := local_request_HeadscaleService_RegisterMachine_0(annotatedContext, inboundMarshaler, server, req, pathParams)
+		resp, md, err := local_request_HeadscaleService_RegisterNode_0(annotatedContext, inboundMarshaler, server, req, pathParams)
 		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
 		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
 		if err != nil {
@@ -1449,11 +1449,11 @@ func RegisterHeadscaleServiceHandlerServer(ctx context.Context, mux *runtime.Ser
 			return
 		}
 
-		forward_HeadscaleService_RegisterMachine_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+		forward_HeadscaleService_RegisterNode_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
 
 	})
 
-	mux.Handle("DELETE", pattern_HeadscaleService_DeleteMachine_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+	mux.Handle("DELETE", pattern_HeadscaleService_DeleteNode_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
 		ctx, cancel := context.WithCancel(req.Context())
 		defer cancel()
 		var stream runtime.ServerTransportStream
@@ -1461,12 +1461,12 @@ func RegisterHeadscaleServiceHandlerServer(ctx context.Context, mux *runtime.Ser
 		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
 		var err error
 		var annotatedContext context.Context
-		annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/headscale.v1.HeadscaleService/DeleteMachine", runtime.WithHTTPPathPattern("/api/v1/machine/{machine_id}"))
+		annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/headscale.v1.HeadscaleService/DeleteNode", runtime.WithHTTPPathPattern("/api/v1/node/{node_id}"))
 		if err != nil {
 			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
 			return
 		}
-		resp, md, err := local_request_HeadscaleService_DeleteMachine_0(annotatedContext, inboundMarshaler, server, req, pathParams)
+		resp, md, err := local_request_HeadscaleService_DeleteNode_0(annotatedContext, inboundMarshaler, server, req, pathParams)
 		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
 		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
 		if err != nil {
@@ -1474,11 +1474,11 @@ func RegisterHeadscaleServiceHandlerServer(ctx context.Context, mux *runtime.Ser
 			return
 		}
 
-		forward_HeadscaleService_DeleteMachine_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+		forward_HeadscaleService_DeleteNode_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
 
 	})
 
-	mux.Handle("POST", pattern_HeadscaleService_ExpireMachine_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+	mux.Handle("POST", pattern_HeadscaleService_ExpireNode_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
 		ctx, cancel := context.WithCancel(req.Context())
 		defer cancel()
 		var stream runtime.ServerTransportStream
@@ -1486,12 +1486,12 @@ func RegisterHeadscaleServiceHandlerServer(ctx context.Context, mux *runtime.Ser
 		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
 		var err error
 		var annotatedContext context.Context
-		annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/headscale.v1.HeadscaleService/ExpireMachine", runtime.WithHTTPPathPattern("/api/v1/machine/{machine_id}/expire"))
+		annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/headscale.v1.HeadscaleService/ExpireNode", runtime.WithHTTPPathPattern("/api/v1/node/{node_id}/expire"))
 		if err != nil {
 			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
 			return
 		}
-		resp, md, err := local_request_HeadscaleService_ExpireMachine_0(annotatedContext, inboundMarshaler, server, req, pathParams)
+		resp, md, err := local_request_HeadscaleService_ExpireNode_0(annotatedContext, inboundMarshaler, server, req, pathParams)
 		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
 		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
 		if err != nil {
@@ -1499,11 +1499,11 @@ func RegisterHeadscaleServiceHandlerServer(ctx context.Context, mux *runtime.Ser
 			return
 		}
 
-		forward_HeadscaleService_ExpireMachine_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+		forward_HeadscaleService_ExpireNode_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
 
 	})
 
-	mux.Handle("POST", pattern_HeadscaleService_RenameMachine_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+	mux.Handle("POST", pattern_HeadscaleService_RenameNode_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
 		ctx, cancel := context.WithCancel(req.Context())
 		defer cancel()
 		var stream runtime.ServerTransportStream
@@ -1511,12 +1511,12 @@ func RegisterHeadscaleServiceHandlerServer(ctx context.Context, mux *runtime.Ser
 		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
 		var err error
 		var annotatedContext context.Context
-		annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/headscale.v1.HeadscaleService/RenameMachine", runtime.WithHTTPPathPattern("/api/v1/machine/{machine_id}/rename/{new_name}"))
+		annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/headscale.v1.HeadscaleService/RenameNode", runtime.WithHTTPPathPattern("/api/v1/node/{node_id}/rename/{new_name}"))
 		if err != nil {
 			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
 			return
 		}
-		resp, md, err := local_request_HeadscaleService_RenameMachine_0(annotatedContext, inboundMarshaler, server, req, pathParams)
+		resp, md, err := local_request_HeadscaleService_RenameNode_0(annotatedContext, inboundMarshaler, server, req, pathParams)
 		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
 		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
 		if err != nil {
@@ -1524,11 +1524,11 @@ func RegisterHeadscaleServiceHandlerServer(ctx context.Context, mux *runtime.Ser
 			return
 		}
 
-		forward_HeadscaleService_RenameMachine_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+		forward_HeadscaleService_RenameNode_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
 
 	})
 
-	mux.Handle("GET", pattern_HeadscaleService_ListMachines_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+	mux.Handle("GET", pattern_HeadscaleService_ListNodes_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
 		ctx, cancel := context.WithCancel(req.Context())
 		defer cancel()
 		var stream runtime.ServerTransportStream
@@ -1536,12 +1536,12 @@ func RegisterHeadscaleServiceHandlerServer(ctx context.Context, mux *runtime.Ser
 		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
 		var err error
 		var annotatedContext context.Context
-		annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/headscale.v1.HeadscaleService/ListMachines", runtime.WithHTTPPathPattern("/api/v1/machine"))
+		annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/headscale.v1.HeadscaleService/ListNodes", runtime.WithHTTPPathPattern("/api/v1/node"))
 		if err != nil {
 			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
 			return
 		}
-		resp, md, err := local_request_HeadscaleService_ListMachines_0(annotatedContext, inboundMarshaler, server, req, pathParams)
+		resp, md, err := local_request_HeadscaleService_ListNodes_0(annotatedContext, inboundMarshaler, server, req, pathParams)
 		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
 		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
 		if err != nil {
@@ -1549,11 +1549,11 @@ func RegisterHeadscaleServiceHandlerServer(ctx context.Context, mux *runtime.Ser
 			return
 		}
 
-		forward_HeadscaleService_ListMachines_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+		forward_HeadscaleService_ListNodes_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
 
 	})
 
-	mux.Handle("POST", pattern_HeadscaleService_MoveMachine_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+	mux.Handle("POST", pattern_HeadscaleService_MoveNode_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
 		ctx, cancel := context.WithCancel(req.Context())
 		defer cancel()
 		var stream runtime.ServerTransportStream
@@ -1561,12 +1561,12 @@ func RegisterHeadscaleServiceHandlerServer(ctx context.Context, mux *runtime.Ser
 		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
 		var err error
 		var annotatedContext context.Context
-		annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/headscale.v1.HeadscaleService/MoveMachine", runtime.WithHTTPPathPattern("/api/v1/machine/{machine_id}/user"))
+		annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/headscale.v1.HeadscaleService/MoveNode", runtime.WithHTTPPathPattern("/api/v1/node/{node_id}/user"))
 		if err != nil {
 			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
 			return
 		}
-		resp, md, err := local_request_HeadscaleService_MoveMachine_0(annotatedContext, inboundMarshaler, server, req, pathParams)
+		resp, md, err := local_request_HeadscaleService_MoveNode_0(annotatedContext, inboundMarshaler, server, req, pathParams)
 		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
 		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
 		if err != nil {
@@ -1574,7 +1574,7 @@ func RegisterHeadscaleServiceHandlerServer(ctx context.Context, mux *runtime.Ser
 			return
 		}
 
-		forward_HeadscaleService_MoveMachine_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+		forward_HeadscaleService_MoveNode_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
 
 	})
 
@@ -1653,7 +1653,7 @@ func RegisterHeadscaleServiceHandlerServer(ctx context.Context, mux *runtime.Ser
 
 	})
 
-	mux.Handle("GET", pattern_HeadscaleService_GetMachineRoutes_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+	mux.Handle("GET", pattern_HeadscaleService_GetNodeRoutes_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
 		ctx, cancel := context.WithCancel(req.Context())
 		defer cancel()
 		var stream runtime.ServerTransportStream
@@ -1661,12 +1661,12 @@ func RegisterHeadscaleServiceHandlerServer(ctx context.Context, mux *runtime.Ser
 		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
 		var err error
 		var annotatedContext context.Context
-		annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/headscale.v1.HeadscaleService/GetMachineRoutes", runtime.WithHTTPPathPattern("/api/v1/machine/{machine_id}/routes"))
+		annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/headscale.v1.HeadscaleService/GetNodeRoutes", runtime.WithHTTPPathPattern("/api/v1/node/{node_id}/routes"))
 		if err != nil {
 			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
 			return
 		}
-		resp, md, err := local_request_HeadscaleService_GetMachineRoutes_0(annotatedContext, inboundMarshaler, server, req, pathParams)
+		resp, md, err := local_request_HeadscaleService_GetNodeRoutes_0(annotatedContext, inboundMarshaler, server, req, pathParams)
 		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
 		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
 		if err != nil {
@@ -1674,7 +1674,7 @@ func RegisterHeadscaleServiceHandlerServer(ctx context.Context, mux *runtime.Ser
 			return
 		}
 
-		forward_HeadscaleService_GetMachineRoutes_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+		forward_HeadscaleService_GetNodeRoutes_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
 
 	})
 
@@ -1995,47 +1995,47 @@ func RegisterHeadscaleServiceHandlerClient(ctx context.Context, mux *runtime.Ser
 
 	})
 
-	mux.Handle("POST", pattern_HeadscaleService_DebugCreateMachine_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+	mux.Handle("POST", pattern_HeadscaleService_DebugCreateNode_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
 		ctx, cancel := context.WithCancel(req.Context())
 		defer cancel()
 		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
 		var err error
 		var annotatedContext context.Context
-		annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/headscale.v1.HeadscaleService/DebugCreateMachine", runtime.WithHTTPPathPattern("/api/v1/debug/machine"))
+		annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/headscale.v1.HeadscaleService/DebugCreateNode", runtime.WithHTTPPathPattern("/api/v1/debug/node"))
 		if err != nil {
 			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
 			return
 		}
-		resp, md, err := request_HeadscaleService_DebugCreateMachine_0(annotatedContext, inboundMarshaler, client, req, pathParams)
+		resp, md, err := request_HeadscaleService_DebugCreateNode_0(annotatedContext, inboundMarshaler, client, req, pathParams)
 		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
 		if err != nil {
 			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
 			return
 		}
 
-		forward_HeadscaleService_DebugCreateMachine_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+		forward_HeadscaleService_DebugCreateNode_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
 
 	})
 
-	mux.Handle("GET", pattern_HeadscaleService_GetMachine_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+	mux.Handle("GET", pattern_HeadscaleService_GetNode_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
 		ctx, cancel := context.WithCancel(req.Context())
 		defer cancel()
 		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
 		var err error
 		var annotatedContext context.Context
-		annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/headscale.v1.HeadscaleService/GetMachine", runtime.WithHTTPPathPattern("/api/v1/machine/{machine_id}"))
+		annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/headscale.v1.HeadscaleService/GetNode", runtime.WithHTTPPathPattern("/api/v1/node/{node_id}"))
 		if err != nil {
 			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
 			return
 		}
-		resp, md, err := request_HeadscaleService_GetMachine_0(annotatedContext, inboundMarshaler, client, req, pathParams)
+		resp, md, err := request_HeadscaleService_GetNode_0(annotatedContext, inboundMarshaler, client, req, pathParams)
 		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
 		if err != nil {
 			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
 			return
 		}
 
-		forward_HeadscaleService_GetMachine_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+		forward_HeadscaleService_GetNode_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
 
 	})
 
@@ -2045,7 +2045,7 @@ func RegisterHeadscaleServiceHandlerClient(ctx context.Context, mux *runtime.Ser
 		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
 		var err error
 		var annotatedContext context.Context
-		annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/headscale.v1.HeadscaleService/SetTags", runtime.WithHTTPPathPattern("/api/v1/machine/{machine_id}/tags"))
+		annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/headscale.v1.HeadscaleService/SetTags", runtime.WithHTTPPathPattern("/api/v1/node/{node_id}/tags"))
 		if err != nil {
 			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
 			return
@@ -2061,135 +2061,135 @@ func RegisterHeadscaleServiceHandlerClient(ctx context.Context, mux *runtime.Ser
 
 	})
 
-	mux.Handle("POST", pattern_HeadscaleService_RegisterMachine_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+	mux.Handle("POST", pattern_HeadscaleService_RegisterNode_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
 		ctx, cancel := context.WithCancel(req.Context())
 		defer cancel()
 		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
 		var err error
 		var annotatedContext context.Context
-		annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/headscale.v1.HeadscaleService/RegisterMachine", runtime.WithHTTPPathPattern("/api/v1/machine/register"))
+		annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/headscale.v1.HeadscaleService/RegisterNode", runtime.WithHTTPPathPattern("/api/v1/node/register"))
 		if err != nil {
 			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
 			return
 		}
-		resp, md, err := request_HeadscaleService_RegisterMachine_0(annotatedContext, inboundMarshaler, client, req, pathParams)
+		resp, md, err := request_HeadscaleService_RegisterNode_0(annotatedContext, inboundMarshaler, client, req, pathParams)
 		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
 		if err != nil {
 			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
 			return
 		}
 
-		forward_HeadscaleService_RegisterMachine_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+		forward_HeadscaleService_RegisterNode_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
 
 	})
 
-	mux.Handle("DELETE", pattern_HeadscaleService_DeleteMachine_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+	mux.Handle("DELETE", pattern_HeadscaleService_DeleteNode_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
 		ctx, cancel := context.WithCancel(req.Context())
 		defer cancel()
 		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
 		var err error
 		var annotatedContext context.Context
-		annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/headscale.v1.HeadscaleService/DeleteMachine", runtime.WithHTTPPathPattern("/api/v1/machine/{machine_id}"))
+		annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/headscale.v1.HeadscaleService/DeleteNode", runtime.WithHTTPPathPattern("/api/v1/node/{node_id}"))
 		if err != nil {
 			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
 			return
 		}
-		resp, md, err := request_HeadscaleService_DeleteMachine_0(annotatedContext, inboundMarshaler, client, req, pathParams)
+		resp, md, err := request_HeadscaleService_DeleteNode_0(annotatedContext, inboundMarshaler, client, req, pathParams)
 		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
 		if err != nil {
 			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
 			return
 		}
 
-		forward_HeadscaleService_DeleteMachine_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+		forward_HeadscaleService_DeleteNode_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
 
 	})
 
-	mux.Handle("POST", pattern_HeadscaleService_ExpireMachine_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+	mux.Handle("POST", pattern_HeadscaleService_ExpireNode_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
 		ctx, cancel := context.WithCancel(req.Context())
 		defer cancel()
 		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
 		var err error
 		var annotatedContext context.Context
-		annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/headscale.v1.HeadscaleService/ExpireMachine", runtime.WithHTTPPathPattern("/api/v1/machine/{machine_id}/expire"))
+		annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/headscale.v1.HeadscaleService/ExpireNode", runtime.WithHTTPPathPattern("/api/v1/node/{node_id}/expire"))
 		if err != nil {
 			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
 			return
 		}
-		resp, md, err := request_HeadscaleService_ExpireMachine_0(annotatedContext, inboundMarshaler, client, req, pathParams)
+		resp, md, err := request_HeadscaleService_ExpireNode_0(annotatedContext, inboundMarshaler, client, req, pathParams)
 		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
 		if err != nil {
 			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
 			return
 		}
 
-		forward_HeadscaleService_ExpireMachine_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+		forward_HeadscaleService_ExpireNode_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
 
 	})
 
-	mux.Handle("POST", pattern_HeadscaleService_RenameMachine_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+	mux.Handle("POST", pattern_HeadscaleService_RenameNode_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
 		ctx, cancel := context.WithCancel(req.Context())
 		defer cancel()
 		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
 		var err error
 		var annotatedContext context.Context
-		annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/headscale.v1.HeadscaleService/RenameMachine", runtime.WithHTTPPathPattern("/api/v1/machine/{machine_id}/rename/{new_name}"))
+		annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/headscale.v1.HeadscaleService/RenameNode", runtime.WithHTTPPathPattern("/api/v1/node/{node_id}/rename/{new_name}"))
 		if err != nil {
 			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
 			return
 		}
-		resp, md, err := request_HeadscaleService_RenameMachine_0(annotatedContext, inboundMarshaler, client, req, pathParams)
+		resp, md, err := request_HeadscaleService_RenameNode_0(annotatedContext, inboundMarshaler, client, req, pathParams)
 		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
 		if err != nil {
 			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
 			return
 		}
 
-		forward_HeadscaleService_RenameMachine_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+		forward_HeadscaleService_RenameNode_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
 
 	})
 
-	mux.Handle("GET", pattern_HeadscaleService_ListMachines_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+	mux.Handle("GET", pattern_HeadscaleService_ListNodes_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
 		ctx, cancel := context.WithCancel(req.Context())
 		defer cancel()
 		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
 		var err error
 		var annotatedContext context.Context
-		annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/headscale.v1.HeadscaleService/ListMachines", runtime.WithHTTPPathPattern("/api/v1/machine"))
+		annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/headscale.v1.HeadscaleService/ListNodes", runtime.WithHTTPPathPattern("/api/v1/node"))
 		if err != nil {
 			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
 			return
 		}
-		resp, md, err := request_HeadscaleService_ListMachines_0(annotatedContext, inboundMarshaler, client, req, pathParams)
+		resp, md, err := request_HeadscaleService_ListNodes_0(annotatedContext, inboundMarshaler, client, req, pathParams)
 		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
 		if err != nil {
 			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
 			return
 		}
 
-		forward_HeadscaleService_ListMachines_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+		forward_HeadscaleService_ListNodes_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
 
 	})
 
-	mux.Handle("POST", pattern_HeadscaleService_MoveMachine_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+	mux.Handle("POST", pattern_HeadscaleService_MoveNode_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
 		ctx, cancel := context.WithCancel(req.Context())
 		defer cancel()
 		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
 		var err error
 		var annotatedContext context.Context
-		annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/headscale.v1.HeadscaleService/MoveMachine", runtime.WithHTTPPathPattern("/api/v1/machine/{machine_id}/user"))
+		annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/headscale.v1.HeadscaleService/MoveNode", runtime.WithHTTPPathPattern("/api/v1/node/{node_id}/user"))
 		if err != nil {
 			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
 			return
 		}
-		resp, md, err := request_HeadscaleService_MoveMachine_0(annotatedContext, inboundMarshaler, client, req, pathParams)
+		resp, md, err := request_HeadscaleService_MoveNode_0(annotatedContext, inboundMarshaler, client, req, pathParams)
 		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
 		if err != nil {
 			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
 			return
 		}
 
-		forward_HeadscaleService_MoveMachine_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+		forward_HeadscaleService_MoveNode_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
 
 	})
 
@@ -2259,25 +2259,25 @@ func RegisterHeadscaleServiceHandlerClient(ctx context.Context, mux *runtime.Ser
 
 	})
 
-	mux.Handle("GET", pattern_HeadscaleService_GetMachineRoutes_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+	mux.Handle("GET", pattern_HeadscaleService_GetNodeRoutes_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
 		ctx, cancel := context.WithCancel(req.Context())
 		defer cancel()
 		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
 		var err error
 		var annotatedContext context.Context
-		annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/headscale.v1.HeadscaleService/GetMachineRoutes", runtime.WithHTTPPathPattern("/api/v1/machine/{machine_id}/routes"))
+		annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/headscale.v1.HeadscaleService/GetNodeRoutes", runtime.WithHTTPPathPattern("/api/v1/node/{node_id}/routes"))
 		if err != nil {
 			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
 			return
 		}
-		resp, md, err := request_HeadscaleService_GetMachineRoutes_0(annotatedContext, inboundMarshaler, client, req, pathParams)
+		resp, md, err := request_HeadscaleService_GetNodeRoutes_0(annotatedContext, inboundMarshaler, client, req, pathParams)
 		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
 		if err != nil {
 			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
 			return
 		}
 
-		forward_HeadscaleService_GetMachineRoutes_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+		forward_HeadscaleService_GetNodeRoutes_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
 
 	})
 
@@ -2389,23 +2389,23 @@ var (
 
 	pattern_HeadscaleService_ListPreAuthKeys_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"api", "v1", "preauthkey"}, ""))
 
-	pattern_HeadscaleService_DebugCreateMachine_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"api", "v1", "debug", "machine"}, ""))
+	pattern_HeadscaleService_DebugCreateNode_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"api", "v1", "debug", "node"}, ""))
 
-	pattern_HeadscaleService_GetMachine_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3}, []string{"api", "v1", "machine", "machine_id"}, ""))
+	pattern_HeadscaleService_GetNode_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3}, []string{"api", "v1", "node", "node_id"}, ""))
 
-	pattern_HeadscaleService_SetTags_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3, 2, 4}, []string{"api", "v1", "machine", "machine_id", "tags"}, ""))
+	pattern_HeadscaleService_SetTags_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3, 2, 4}, []string{"api", "v1", "node", "node_id", "tags"}, ""))
 
-	pattern_HeadscaleService_RegisterMachine_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"api", "v1", "machine", "register"}, ""))
+	pattern_HeadscaleService_RegisterNode_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"api", "v1", "node", "register"}, ""))
 
-	pattern_HeadscaleService_DeleteMachine_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3}, []string{"api", "v1", "machine", "machine_id"}, ""))
+	pattern_HeadscaleService_DeleteNode_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3}, []string{"api", "v1", "node", "node_id"}, ""))
 
-	pattern_HeadscaleService_ExpireMachine_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3, 2, 4}, []string{"api", "v1", "machine", "machine_id", "expire"}, ""))
+	pattern_HeadscaleService_ExpireNode_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3, 2, 4}, []string{"api", "v1", "node", "node_id", "expire"}, ""))
 
-	pattern_HeadscaleService_RenameMachine_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3, 2, 4, 1, 0, 4, 1, 5, 5}, []string{"api", "v1", "machine", "machine_id", "rename", "new_name"}, ""))
+	pattern_HeadscaleService_RenameNode_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3, 2, 4, 1, 0, 4, 1, 5, 5}, []string{"api", "v1", "node", "node_id", "rename", "new_name"}, ""))
 
-	pattern_HeadscaleService_ListMachines_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"api", "v1", "machine"}, ""))
+	pattern_HeadscaleService_ListNodes_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"api", "v1", "node"}, ""))
 
-	pattern_HeadscaleService_MoveMachine_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3, 2, 4}, []string{"api", "v1", "machine", "machine_id", "user"}, ""))
+	pattern_HeadscaleService_MoveNode_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3, 2, 4}, []string{"api", "v1", "node", "node_id", "user"}, ""))
 
 	pattern_HeadscaleService_GetRoutes_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"api", "v1", "routes"}, ""))
 
@@ -2413,7 +2413,7 @@ var (
 
 	pattern_HeadscaleService_DisableRoute_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3, 2, 4}, []string{"api", "v1", "routes", "route_id", "disable"}, ""))
 
-	pattern_HeadscaleService_GetMachineRoutes_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3, 2, 4}, []string{"api", "v1", "machine", "machine_id", "routes"}, ""))
+	pattern_HeadscaleService_GetNodeRoutes_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3, 2, 4}, []string{"api", "v1", "node", "node_id", "routes"}, ""))
 
 	pattern_HeadscaleService_DeleteRoute_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3}, []string{"api", "v1", "routes", "route_id"}, ""))
 
@@ -2441,23 +2441,23 @@ var (
 
 	forward_HeadscaleService_ListPreAuthKeys_0 = runtime.ForwardResponseMessage
 
-	forward_HeadscaleService_DebugCreateMachine_0 = runtime.ForwardResponseMessage
+	forward_HeadscaleService_DebugCreateNode_0 = runtime.ForwardResponseMessage
 
-	forward_HeadscaleService_GetMachine_0 = runtime.ForwardResponseMessage
+	forward_HeadscaleService_GetNode_0 = runtime.ForwardResponseMessage
 
 	forward_HeadscaleService_SetTags_0 = runtime.ForwardResponseMessage
 
-	forward_HeadscaleService_RegisterMachine_0 = runtime.ForwardResponseMessage
+	forward_HeadscaleService_RegisterNode_0 = runtime.ForwardResponseMessage
 
-	forward_HeadscaleService_DeleteMachine_0 = runtime.ForwardResponseMessage
+	forward_HeadscaleService_DeleteNode_0 = runtime.ForwardResponseMessage
 
-	forward_HeadscaleService_ExpireMachine_0 = runtime.ForwardResponseMessage
+	forward_HeadscaleService_ExpireNode_0 = runtime.ForwardResponseMessage
 
-	forward_HeadscaleService_RenameMachine_0 = runtime.ForwardResponseMessage
+	forward_HeadscaleService_RenameNode_0 = runtime.ForwardResponseMessage
 
-	forward_HeadscaleService_ListMachines_0 = runtime.ForwardResponseMessage
+	forward_HeadscaleService_ListNodes_0 = runtime.ForwardResponseMessage
 
-	forward_HeadscaleService_MoveMachine_0 = runtime.ForwardResponseMessage
+	forward_HeadscaleService_MoveNode_0 = runtime.ForwardResponseMessage
 
 	forward_HeadscaleService_GetRoutes_0 = runtime.ForwardResponseMessage
 
@@ -2465,7 +2465,7 @@ var (
 
 	forward_HeadscaleService_DisableRoute_0 = runtime.ForwardResponseMessage
 
-	forward_HeadscaleService_GetMachineRoutes_0 = runtime.ForwardResponseMessage
+	forward_HeadscaleService_GetNodeRoutes_0 = runtime.ForwardResponseMessage
 
 	forward_HeadscaleService_DeleteRoute_0 = runtime.ForwardResponseMessage
 
diff --git a/gen/go/headscale/v1/headscale_grpc.pb.go b/gen/go/headscale/v1/headscale_grpc.pb.go
index b5f67c7faa..fab8f522ce 100644
--- a/gen/go/headscale/v1/headscale_grpc.pb.go
+++ b/gen/go/headscale/v1/headscale_grpc.pb.go
@@ -19,31 +19,31 @@ import (
 const _ = grpc.SupportPackageIsVersion7
 
 const (
-	HeadscaleService_GetUser_FullMethodName            = "/headscale.v1.HeadscaleService/GetUser"
-	HeadscaleService_CreateUser_FullMethodName         = "/headscale.v1.HeadscaleService/CreateUser"
-	HeadscaleService_RenameUser_FullMethodName         = "/headscale.v1.HeadscaleService/RenameUser"
-	HeadscaleService_DeleteUser_FullMethodName         = "/headscale.v1.HeadscaleService/DeleteUser"
-	HeadscaleService_ListUsers_FullMethodName          = "/headscale.v1.HeadscaleService/ListUsers"
-	HeadscaleService_CreatePreAuthKey_FullMethodName   = "/headscale.v1.HeadscaleService/CreatePreAuthKey"
-	HeadscaleService_ExpirePreAuthKey_FullMethodName   = "/headscale.v1.HeadscaleService/ExpirePreAuthKey"
-	HeadscaleService_ListPreAuthKeys_FullMethodName    = "/headscale.v1.HeadscaleService/ListPreAuthKeys"
-	HeadscaleService_DebugCreateMachine_FullMethodName = "/headscale.v1.HeadscaleService/DebugCreateMachine"
-	HeadscaleService_GetMachine_FullMethodName         = "/headscale.v1.HeadscaleService/GetMachine"
-	HeadscaleService_SetTags_FullMethodName            = "/headscale.v1.HeadscaleService/SetTags"
-	HeadscaleService_RegisterMachine_FullMethodName    = "/headscale.v1.HeadscaleService/RegisterMachine"
-	HeadscaleService_DeleteMachine_FullMethodName      = "/headscale.v1.HeadscaleService/DeleteMachine"
-	HeadscaleService_ExpireMachine_FullMethodName      = "/headscale.v1.HeadscaleService/ExpireMachine"
-	HeadscaleService_RenameMachine_FullMethodName      = "/headscale.v1.HeadscaleService/RenameMachine"
-	HeadscaleService_ListMachines_FullMethodName       = "/headscale.v1.HeadscaleService/ListMachines"
-	HeadscaleService_MoveMachine_FullMethodName        = "/headscale.v1.HeadscaleService/MoveMachine"
-	HeadscaleService_GetRoutes_FullMethodName          = "/headscale.v1.HeadscaleService/GetRoutes"
-	HeadscaleService_EnableRoute_FullMethodName        = "/headscale.v1.HeadscaleService/EnableRoute"
-	HeadscaleService_DisableRoute_FullMethodName       = "/headscale.v1.HeadscaleService/DisableRoute"
-	HeadscaleService_GetMachineRoutes_FullMethodName   = "/headscale.v1.HeadscaleService/GetMachineRoutes"
-	HeadscaleService_DeleteRoute_FullMethodName        = "/headscale.v1.HeadscaleService/DeleteRoute"
-	HeadscaleService_CreateApiKey_FullMethodName       = "/headscale.v1.HeadscaleService/CreateApiKey"
-	HeadscaleService_ExpireApiKey_FullMethodName       = "/headscale.v1.HeadscaleService/ExpireApiKey"
-	HeadscaleService_ListApiKeys_FullMethodName        = "/headscale.v1.HeadscaleService/ListApiKeys"
+	HeadscaleService_GetUser_FullMethodName          = "/headscale.v1.HeadscaleService/GetUser"
+	HeadscaleService_CreateUser_FullMethodName       = "/headscale.v1.HeadscaleService/CreateUser"
+	HeadscaleService_RenameUser_FullMethodName       = "/headscale.v1.HeadscaleService/RenameUser"
+	HeadscaleService_DeleteUser_FullMethodName       = "/headscale.v1.HeadscaleService/DeleteUser"
+	HeadscaleService_ListUsers_FullMethodName        = "/headscale.v1.HeadscaleService/ListUsers"
+	HeadscaleService_CreatePreAuthKey_FullMethodName = "/headscale.v1.HeadscaleService/CreatePreAuthKey"
+	HeadscaleService_ExpirePreAuthKey_FullMethodName = "/headscale.v1.HeadscaleService/ExpirePreAuthKey"
+	HeadscaleService_ListPreAuthKeys_FullMethodName  = "/headscale.v1.HeadscaleService/ListPreAuthKeys"
+	HeadscaleService_DebugCreateNode_FullMethodName  = "/headscale.v1.HeadscaleService/DebugCreateNode"
+	HeadscaleService_GetNode_FullMethodName          = "/headscale.v1.HeadscaleService/GetNode"
+	HeadscaleService_SetTags_FullMethodName          = "/headscale.v1.HeadscaleService/SetTags"
+	HeadscaleService_RegisterNode_FullMethodName     = "/headscale.v1.HeadscaleService/RegisterNode"
+	HeadscaleService_DeleteNode_FullMethodName       = "/headscale.v1.HeadscaleService/DeleteNode"
+	HeadscaleService_ExpireNode_FullMethodName       = "/headscale.v1.HeadscaleService/ExpireNode"
+	HeadscaleService_RenameNode_FullMethodName       = "/headscale.v1.HeadscaleService/RenameNode"
+	HeadscaleService_ListNodes_FullMethodName        = "/headscale.v1.HeadscaleService/ListNodes"
+	HeadscaleService_MoveNode_FullMethodName         = "/headscale.v1.HeadscaleService/MoveNode"
+	HeadscaleService_GetRoutes_FullMethodName        = "/headscale.v1.HeadscaleService/GetRoutes"
+	HeadscaleService_EnableRoute_FullMethodName      = "/headscale.v1.HeadscaleService/EnableRoute"
+	HeadscaleService_DisableRoute_FullMethodName     = "/headscale.v1.HeadscaleService/DisableRoute"
+	HeadscaleService_GetNodeRoutes_FullMethodName    = "/headscale.v1.HeadscaleService/GetNodeRoutes"
+	HeadscaleService_DeleteRoute_FullMethodName      = "/headscale.v1.HeadscaleService/DeleteRoute"
+	HeadscaleService_CreateApiKey_FullMethodName     = "/headscale.v1.HeadscaleService/CreateApiKey"
+	HeadscaleService_ExpireApiKey_FullMethodName     = "/headscale.v1.HeadscaleService/ExpireApiKey"
+	HeadscaleService_ListApiKeys_FullMethodName      = "/headscale.v1.HeadscaleService/ListApiKeys"
 )
 
 // HeadscaleServiceClient is the client API for HeadscaleService service.
@@ -60,21 +60,21 @@ type HeadscaleServiceClient interface {
 	CreatePreAuthKey(ctx context.Context, in *CreatePreAuthKeyRequest, opts ...grpc.CallOption) (*CreatePreAuthKeyResponse, error)
 	ExpirePreAuthKey(ctx context.Context, in *ExpirePreAuthKeyRequest, opts ...grpc.CallOption) (*ExpirePreAuthKeyResponse, error)
 	ListPreAuthKeys(ctx context.Context, in *ListPreAuthKeysRequest, opts ...grpc.CallOption) (*ListPreAuthKeysResponse, error)
-	// --- Machine start ---
-	DebugCreateMachine(ctx context.Context, in *DebugCreateMachineRequest, opts ...grpc.CallOption) (*DebugCreateMachineResponse, error)
-	GetMachine(ctx context.Context, in *GetMachineRequest, opts ...grpc.CallOption) (*GetMachineResponse, error)
+	// --- Node start ---
+	DebugCreateNode(ctx context.Context, in *DebugCreateNodeRequest, opts ...grpc.CallOption) (*DebugCreateNodeResponse, error)
+	GetNode(ctx context.Context, in *GetNodeRequest, opts ...grpc.CallOption) (*GetNodeResponse, error)
 	SetTags(ctx context.Context, in *SetTagsRequest, opts ...grpc.CallOption) (*SetTagsResponse, error)
-	RegisterMachine(ctx context.Context, in *RegisterMachineRequest, opts ...grpc.CallOption) (*RegisterMachineResponse, error)
-	DeleteMachine(ctx context.Context, in *DeleteMachineRequest, opts ...grpc.CallOption) (*DeleteMachineResponse, error)
-	ExpireMachine(ctx context.Context, in *ExpireMachineRequest, opts ...grpc.CallOption) (*ExpireMachineResponse, error)
-	RenameMachine(ctx context.Context, in *RenameMachineRequest, opts ...grpc.CallOption) (*RenameMachineResponse, error)
-	ListMachines(ctx context.Context, in *ListMachinesRequest, opts ...grpc.CallOption) (*ListMachinesResponse, error)
-	MoveMachine(ctx context.Context, in *MoveMachineRequest, opts ...grpc.CallOption) (*MoveMachineResponse, error)
+	RegisterNode(ctx context.Context, in *RegisterNodeRequest, opts ...grpc.CallOption) (*RegisterNodeResponse, error)
+	DeleteNode(ctx context.Context, in *DeleteNodeRequest, opts ...grpc.CallOption) (*DeleteNodeResponse, error)
+	ExpireNode(ctx context.Context, in *ExpireNodeRequest, opts ...grpc.CallOption) (*ExpireNodeResponse, error)
+	RenameNode(ctx context.Context, in *RenameNodeRequest, opts ...grpc.CallOption) (*RenameNodeResponse, error)
+	ListNodes(ctx context.Context, in *ListNodesRequest, opts ...grpc.CallOption) (*ListNodesResponse, error)
+	MoveNode(ctx context.Context, in *MoveNodeRequest, opts ...grpc.CallOption) (*MoveNodeResponse, error)
 	// --- Route start ---
 	GetRoutes(ctx context.Context, in *GetRoutesRequest, opts ...grpc.CallOption) (*GetRoutesResponse, error)
 	EnableRoute(ctx context.Context, in *EnableRouteRequest, opts ...grpc.CallOption) (*EnableRouteResponse, error)
 	DisableRoute(ctx context.Context, in *DisableRouteRequest, opts ...grpc.CallOption) (*DisableRouteResponse, error)
-	GetMachineRoutes(ctx context.Context, in *GetMachineRoutesRequest, opts ...grpc.CallOption) (*GetMachineRoutesResponse, error)
+	GetNodeRoutes(ctx context.Context, in *GetNodeRoutesRequest, opts ...grpc.CallOption) (*GetNodeRoutesResponse, error)
 	DeleteRoute(ctx context.Context, in *DeleteRouteRequest, opts ...grpc.CallOption) (*DeleteRouteResponse, error)
 	// --- ApiKeys start ---
 	CreateApiKey(ctx context.Context, in *CreateApiKeyRequest, opts ...grpc.CallOption) (*CreateApiKeyResponse, error)
@@ -162,18 +162,18 @@ func (c *headscaleServiceClient) ListPreAuthKeys(ctx context.Context, in *ListPr
 	return out, nil
 }
 
-func (c *headscaleServiceClient) DebugCreateMachine(ctx context.Context, in *DebugCreateMachineRequest, opts ...grpc.CallOption) (*DebugCreateMachineResponse, error) {
-	out := new(DebugCreateMachineResponse)
-	err := c.cc.Invoke(ctx, HeadscaleService_DebugCreateMachine_FullMethodName, in, out, opts...)
+func (c *headscaleServiceClient) DebugCreateNode(ctx context.Context, in *DebugCreateNodeRequest, opts ...grpc.CallOption) (*DebugCreateNodeResponse, error) {
+	out := new(DebugCreateNodeResponse)
+	err := c.cc.Invoke(ctx, HeadscaleService_DebugCreateNode_FullMethodName, in, out, opts...)
 	if err != nil {
 		return nil, err
 	}
 	return out, nil
 }
 
-func (c *headscaleServiceClient) GetMachine(ctx context.Context, in *GetMachineRequest, opts ...grpc.CallOption) (*GetMachineResponse, error) {
-	out := new(GetMachineResponse)
-	err := c.cc.Invoke(ctx, HeadscaleService_GetMachine_FullMethodName, in, out, opts...)
+func (c *headscaleServiceClient) GetNode(ctx context.Context, in *GetNodeRequest, opts ...grpc.CallOption) (*GetNodeResponse, error) {
+	out := new(GetNodeResponse)
+	err := c.cc.Invoke(ctx, HeadscaleService_GetNode_FullMethodName, in, out, opts...)
 	if err != nil {
 		return nil, err
 	}
@@ -189,54 +189,54 @@ func (c *headscaleServiceClient) SetTags(ctx context.Context, in *SetTagsRequest
 	return out, nil
 }
 
-func (c *headscaleServiceClient) RegisterMachine(ctx context.Context, in *RegisterMachineRequest, opts ...grpc.CallOption) (*RegisterMachineResponse, error) {
-	out := new(RegisterMachineResponse)
-	err := c.cc.Invoke(ctx, HeadscaleService_RegisterMachine_FullMethodName, in, out, opts...)
+func (c *headscaleServiceClient) RegisterNode(ctx context.Context, in *RegisterNodeRequest, opts ...grpc.CallOption) (*RegisterNodeResponse, error) {
+	out := new(RegisterNodeResponse)
+	err := c.cc.Invoke(ctx, HeadscaleService_RegisterNode_FullMethodName, in, out, opts...)
 	if err != nil {
 		return nil, err
 	}
 	return out, nil
 }
 
-func (c *headscaleServiceClient) DeleteMachine(ctx context.Context, in *DeleteMachineRequest, opts ...grpc.CallOption) (*DeleteMachineResponse, error) {
-	out := new(DeleteMachineResponse)
-	err := c.cc.Invoke(ctx, HeadscaleService_DeleteMachine_FullMethodName, in, out, opts...)
+func (c *headscaleServiceClient) DeleteNode(ctx context.Context, in *DeleteNodeRequest, opts ...grpc.CallOption) (*DeleteNodeResponse, error) {
+	out := new(DeleteNodeResponse)
+	err := c.cc.Invoke(ctx, HeadscaleService_DeleteNode_FullMethodName, in, out, opts...)
 	if err != nil {
 		return nil, err
 	}
 	return out, nil
 }
 
-func (c *headscaleServiceClient) ExpireMachine(ctx context.Context, in *ExpireMachineRequest, opts ...grpc.CallOption) (*ExpireMachineResponse, error) {
-	out := new(ExpireMachineResponse)
-	err := c.cc.Invoke(ctx, HeadscaleService_ExpireMachine_FullMethodName, in, out, opts...)
+func (c *headscaleServiceClient) ExpireNode(ctx context.Context, in *ExpireNodeRequest, opts ...grpc.CallOption) (*ExpireNodeResponse, error) {
+	out := new(ExpireNodeResponse)
+	err := c.cc.Invoke(ctx, HeadscaleService_ExpireNode_FullMethodName, in, out, opts...)
 	if err != nil {
 		return nil, err
 	}
 	return out, nil
 }
 
-func (c *headscaleServiceClient) RenameMachine(ctx context.Context, in *RenameMachineRequest, opts ...grpc.CallOption) (*RenameMachineResponse, error) {
-	out := new(RenameMachineResponse)
-	err := c.cc.Invoke(ctx, HeadscaleService_RenameMachine_FullMethodName, in, out, opts...)
+func (c *headscaleServiceClient) RenameNode(ctx context.Context, in *RenameNodeRequest, opts ...grpc.CallOption) (*RenameNodeResponse, error) {
+	out := new(RenameNodeResponse)
+	err := c.cc.Invoke(ctx, HeadscaleService_RenameNode_FullMethodName, in, out, opts...)
 	if err != nil {
 		return nil, err
 	}
 	return out, nil
 }
 
-func (c *headscaleServiceClient) ListMachines(ctx context.Context, in *ListMachinesRequest, opts ...grpc.CallOption) (*ListMachinesResponse, error) {
-	out := new(ListMachinesResponse)
-	err := c.cc.Invoke(ctx, HeadscaleService_ListMachines_FullMethodName, in, out, opts...)
+func (c *headscaleServiceClient) ListNodes(ctx context.Context, in *ListNodesRequest, opts ...grpc.CallOption) (*ListNodesResponse, error) {
+	out := new(ListNodesResponse)
+	err := c.cc.Invoke(ctx, HeadscaleService_ListNodes_FullMethodName, in, out, opts...)
 	if err != nil {
 		return nil, err
 	}
 	return out, nil
 }
 
-func (c *headscaleServiceClient) MoveMachine(ctx context.Context, in *MoveMachineRequest, opts ...grpc.CallOption) (*MoveMachineResponse, error) {
-	out := new(MoveMachineResponse)
-	err := c.cc.Invoke(ctx, HeadscaleService_MoveMachine_FullMethodName, in, out, opts...)
+func (c *headscaleServiceClient) MoveNode(ctx context.Context, in *MoveNodeRequest, opts ...grpc.CallOption) (*MoveNodeResponse, error) {
+	out := new(MoveNodeResponse)
+	err := c.cc.Invoke(ctx, HeadscaleService_MoveNode_FullMethodName, in, out, opts...)
 	if err != nil {
 		return nil, err
 	}
@@ -270,9 +270,9 @@ func (c *headscaleServiceClient) DisableRoute(ctx context.Context, in *DisableRo
 	return out, nil
 }
 
-func (c *headscaleServiceClient) GetMachineRoutes(ctx context.Context, in *GetMachineRoutesRequest, opts ...grpc.CallOption) (*GetMachineRoutesResponse, error) {
-	out := new(GetMachineRoutesResponse)
-	err := c.cc.Invoke(ctx, HeadscaleService_GetMachineRoutes_FullMethodName, in, out, opts...)
+func (c *headscaleServiceClient) GetNodeRoutes(ctx context.Context, in *GetNodeRoutesRequest, opts ...grpc.CallOption) (*GetNodeRoutesResponse, error) {
+	out := new(GetNodeRoutesResponse)
+	err := c.cc.Invoke(ctx, HeadscaleService_GetNodeRoutes_FullMethodName, in, out, opts...)
 	if err != nil {
 		return nil, err
 	}
@@ -329,21 +329,21 @@ type HeadscaleServiceServer interface {
 	CreatePreAuthKey(context.Context, *CreatePreAuthKeyRequest) (*CreatePreAuthKeyResponse, error)
 	ExpirePreAuthKey(context.Context, *ExpirePreAuthKeyRequest) (*ExpirePreAuthKeyResponse, error)
 	ListPreAuthKeys(context.Context, *ListPreAuthKeysRequest) (*ListPreAuthKeysResponse, error)
-	// --- Machine start ---
-	DebugCreateMachine(context.Context, *DebugCreateMachineRequest) (*DebugCreateMachineResponse, error)
-	GetMachine(context.Context, *GetMachineRequest) (*GetMachineResponse, error)
+	// --- Node start ---
+	DebugCreateNode(context.Context, *DebugCreateNodeRequest) (*DebugCreateNodeResponse, error)
+	GetNode(context.Context, *GetNodeRequest) (*GetNodeResponse, error)
 	SetTags(context.Context, *SetTagsRequest) (*SetTagsResponse, error)
-	RegisterMachine(context.Context, *RegisterMachineRequest) (*RegisterMachineResponse, error)
-	DeleteMachine(context.Context, *DeleteMachineRequest) (*DeleteMachineResponse, error)
-	ExpireMachine(context.Context, *ExpireMachineRequest) (*ExpireMachineResponse, error)
-	RenameMachine(context.Context, *RenameMachineRequest) (*RenameMachineResponse, error)
-	ListMachines(context.Context, *ListMachinesRequest) (*ListMachinesResponse, error)
-	MoveMachine(context.Context, *MoveMachineRequest) (*MoveMachineResponse, error)
+	RegisterNode(context.Context, *RegisterNodeRequest) (*RegisterNodeResponse, error)
+	DeleteNode(context.Context, *DeleteNodeRequest) (*DeleteNodeResponse, error)
+	ExpireNode(context.Context, *ExpireNodeRequest) (*ExpireNodeResponse, error)
+	RenameNode(context.Context, *RenameNodeRequest) (*RenameNodeResponse, error)
+	ListNodes(context.Context, *ListNodesRequest) (*ListNodesResponse, error)
+	MoveNode(context.Context, *MoveNodeRequest) (*MoveNodeResponse, error)
 	// --- Route start ---
 	GetRoutes(context.Context, *GetRoutesRequest) (*GetRoutesResponse, error)
 	EnableRoute(context.Context, *EnableRouteRequest) (*EnableRouteResponse, error)
 	DisableRoute(context.Context, *DisableRouteRequest) (*DisableRouteResponse, error)
-	GetMachineRoutes(context.Context, *GetMachineRoutesRequest) (*GetMachineRoutesResponse, error)
+	GetNodeRoutes(context.Context, *GetNodeRoutesRequest) (*GetNodeRoutesResponse, error)
 	DeleteRoute(context.Context, *DeleteRouteRequest) (*DeleteRouteResponse, error)
 	// --- ApiKeys start ---
 	CreateApiKey(context.Context, *CreateApiKeyRequest) (*CreateApiKeyResponse, error)
@@ -380,32 +380,32 @@ func (UnimplementedHeadscaleServiceServer) ExpirePreAuthKey(context.Context, *Ex
 func (UnimplementedHeadscaleServiceServer) ListPreAuthKeys(context.Context, *ListPreAuthKeysRequest) (*ListPreAuthKeysResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method ListPreAuthKeys not implemented")
 }
-func (UnimplementedHeadscaleServiceServer) DebugCreateMachine(context.Context, *DebugCreateMachineRequest) (*DebugCreateMachineResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method DebugCreateMachine not implemented")
+func (UnimplementedHeadscaleServiceServer) DebugCreateNode(context.Context, *DebugCreateNodeRequest) (*DebugCreateNodeResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method DebugCreateNode not implemented")
 }
-func (UnimplementedHeadscaleServiceServer) GetMachine(context.Context, *GetMachineRequest) (*GetMachineResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method GetMachine not implemented")
+func (UnimplementedHeadscaleServiceServer) GetNode(context.Context, *GetNodeRequest) (*GetNodeResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method GetNode not implemented")
 }
 func (UnimplementedHeadscaleServiceServer) SetTags(context.Context, *SetTagsRequest) (*SetTagsResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method SetTags not implemented")
 }
-func (UnimplementedHeadscaleServiceServer) RegisterMachine(context.Context, *RegisterMachineRequest) (*RegisterMachineResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method RegisterMachine not implemented")
+func (UnimplementedHeadscaleServiceServer) RegisterNode(context.Context, *RegisterNodeRequest) (*RegisterNodeResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method RegisterNode not implemented")
 }
-func (UnimplementedHeadscaleServiceServer) DeleteMachine(context.Context, *DeleteMachineRequest) (*DeleteMachineResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method DeleteMachine not implemented")
+func (UnimplementedHeadscaleServiceServer) DeleteNode(context.Context, *DeleteNodeRequest) (*DeleteNodeResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method DeleteNode not implemented")
 }
-func (UnimplementedHeadscaleServiceServer) ExpireMachine(context.Context, *ExpireMachineRequest) (*ExpireMachineResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method ExpireMachine not implemented")
+func (UnimplementedHeadscaleServiceServer) ExpireNode(context.Context, *ExpireNodeRequest) (*ExpireNodeResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method ExpireNode not implemented")
 }
-func (UnimplementedHeadscaleServiceServer) RenameMachine(context.Context, *RenameMachineRequest) (*RenameMachineResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method RenameMachine not implemented")
+func (UnimplementedHeadscaleServiceServer) RenameNode(context.Context, *RenameNodeRequest) (*RenameNodeResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method RenameNode not implemented")
 }
-func (UnimplementedHeadscaleServiceServer) ListMachines(context.Context, *ListMachinesRequest) (*ListMachinesResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method ListMachines not implemented")
+func (UnimplementedHeadscaleServiceServer) ListNodes(context.Context, *ListNodesRequest) (*ListNodesResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method ListNodes not implemented")
 }
-func (UnimplementedHeadscaleServiceServer) MoveMachine(context.Context, *MoveMachineRequest) (*MoveMachineResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method MoveMachine not implemented")
+func (UnimplementedHeadscaleServiceServer) MoveNode(context.Context, *MoveNodeRequest) (*MoveNodeResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method MoveNode not implemented")
 }
 func (UnimplementedHeadscaleServiceServer) GetRoutes(context.Context, *GetRoutesRequest) (*GetRoutesResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method GetRoutes not implemented")
@@ -416,8 +416,8 @@ func (UnimplementedHeadscaleServiceServer) EnableRoute(context.Context, *EnableR
 func (UnimplementedHeadscaleServiceServer) DisableRoute(context.Context, *DisableRouteRequest) (*DisableRouteResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method DisableRoute not implemented")
 }
-func (UnimplementedHeadscaleServiceServer) GetMachineRoutes(context.Context, *GetMachineRoutesRequest) (*GetMachineRoutesResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method GetMachineRoutes not implemented")
+func (UnimplementedHeadscaleServiceServer) GetNodeRoutes(context.Context, *GetNodeRoutesRequest) (*GetNodeRoutesResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method GetNodeRoutes not implemented")
 }
 func (UnimplementedHeadscaleServiceServer) DeleteRoute(context.Context, *DeleteRouteRequest) (*DeleteRouteResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method DeleteRoute not implemented")
@@ -588,38 +588,38 @@ func _HeadscaleService_ListPreAuthKeys_Handler(srv interface{}, ctx context.Cont
 	return interceptor(ctx, in, info, handler)
 }
 
-func _HeadscaleService_DebugCreateMachine_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(DebugCreateMachineRequest)
+func _HeadscaleService_DebugCreateNode_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(DebugCreateNodeRequest)
 	if err := dec(in); err != nil {
 		return nil, err
 	}
 	if interceptor == nil {
-		return srv.(HeadscaleServiceServer).DebugCreateMachine(ctx, in)
+		return srv.(HeadscaleServiceServer).DebugCreateNode(ctx, in)
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
-		FullMethod: HeadscaleService_DebugCreateMachine_FullMethodName,
+		FullMethod: HeadscaleService_DebugCreateNode_FullMethodName,
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(HeadscaleServiceServer).DebugCreateMachine(ctx, req.(*DebugCreateMachineRequest))
+		return srv.(HeadscaleServiceServer).DebugCreateNode(ctx, req.(*DebugCreateNodeRequest))
 	}
 	return interceptor(ctx, in, info, handler)
 }
 
-func _HeadscaleService_GetMachine_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(GetMachineRequest)
+func _HeadscaleService_GetNode_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(GetNodeRequest)
 	if err := dec(in); err != nil {
 		return nil, err
 	}
 	if interceptor == nil {
-		return srv.(HeadscaleServiceServer).GetMachine(ctx, in)
+		return srv.(HeadscaleServiceServer).GetNode(ctx, in)
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
-		FullMethod: HeadscaleService_GetMachine_FullMethodName,
+		FullMethod: HeadscaleService_GetNode_FullMethodName,
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(HeadscaleServiceServer).GetMachine(ctx, req.(*GetMachineRequest))
+		return srv.(HeadscaleServiceServer).GetNode(ctx, req.(*GetNodeRequest))
 	}
 	return interceptor(ctx, in, info, handler)
 }
@@ -642,110 +642,110 @@ func _HeadscaleService_SetTags_Handler(srv interface{}, ctx context.Context, dec
 	return interceptor(ctx, in, info, handler)
 }
 
-func _HeadscaleService_RegisterMachine_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(RegisterMachineRequest)
+func _HeadscaleService_RegisterNode_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(RegisterNodeRequest)
 	if err := dec(in); err != nil {
 		return nil, err
 	}
 	if interceptor == nil {
-		return srv.(HeadscaleServiceServer).RegisterMachine(ctx, in)
+		return srv.(HeadscaleServiceServer).RegisterNode(ctx, in)
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
-		FullMethod: HeadscaleService_RegisterMachine_FullMethodName,
+		FullMethod: HeadscaleService_RegisterNode_FullMethodName,
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(HeadscaleServiceServer).RegisterMachine(ctx, req.(*RegisterMachineRequest))
+		return srv.(HeadscaleServiceServer).RegisterNode(ctx, req.(*RegisterNodeRequest))
 	}
 	return interceptor(ctx, in, info, handler)
 }
 
-func _HeadscaleService_DeleteMachine_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(DeleteMachineRequest)
+func _HeadscaleService_DeleteNode_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(DeleteNodeRequest)
 	if err := dec(in); err != nil {
 		return nil, err
 	}
 	if interceptor == nil {
-		return srv.(HeadscaleServiceServer).DeleteMachine(ctx, in)
+		return srv.(HeadscaleServiceServer).DeleteNode(ctx, in)
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
-		FullMethod: HeadscaleService_DeleteMachine_FullMethodName,
+		FullMethod: HeadscaleService_DeleteNode_FullMethodName,
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(HeadscaleServiceServer).DeleteMachine(ctx, req.(*DeleteMachineRequest))
+		return srv.(HeadscaleServiceServer).DeleteNode(ctx, req.(*DeleteNodeRequest))
 	}
 	return interceptor(ctx, in, info, handler)
 }
 
-func _HeadscaleService_ExpireMachine_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(ExpireMachineRequest)
+func _HeadscaleService_ExpireNode_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(ExpireNodeRequest)
 	if err := dec(in); err != nil {
 		return nil, err
 	}
 	if interceptor == nil {
-		return srv.(HeadscaleServiceServer).ExpireMachine(ctx, in)
+		return srv.(HeadscaleServiceServer).ExpireNode(ctx, in)
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
-		FullMethod: HeadscaleService_ExpireMachine_FullMethodName,
+		FullMethod: HeadscaleService_ExpireNode_FullMethodName,
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(HeadscaleServiceServer).ExpireMachine(ctx, req.(*ExpireMachineRequest))
+		return srv.(HeadscaleServiceServer).ExpireNode(ctx, req.(*ExpireNodeRequest))
 	}
 	return interceptor(ctx, in, info, handler)
 }
 
-func _HeadscaleService_RenameMachine_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(RenameMachineRequest)
+func _HeadscaleService_RenameNode_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(RenameNodeRequest)
 	if err := dec(in); err != nil {
 		return nil, err
 	}
 	if interceptor == nil {
-		return srv.(HeadscaleServiceServer).RenameMachine(ctx, in)
+		return srv.(HeadscaleServiceServer).RenameNode(ctx, in)
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
-		FullMethod: HeadscaleService_RenameMachine_FullMethodName,
+		FullMethod: HeadscaleService_RenameNode_FullMethodName,
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(HeadscaleServiceServer).RenameMachine(ctx, req.(*RenameMachineRequest))
+		return srv.(HeadscaleServiceServer).RenameNode(ctx, req.(*RenameNodeRequest))
 	}
 	return interceptor(ctx, in, info, handler)
 }
 
-func _HeadscaleService_ListMachines_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(ListMachinesRequest)
+func _HeadscaleService_ListNodes_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(ListNodesRequest)
 	if err := dec(in); err != nil {
 		return nil, err
 	}
 	if interceptor == nil {
-		return srv.(HeadscaleServiceServer).ListMachines(ctx, in)
+		return srv.(HeadscaleServiceServer).ListNodes(ctx, in)
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
-		FullMethod: HeadscaleService_ListMachines_FullMethodName,
+		FullMethod: HeadscaleService_ListNodes_FullMethodName,
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(HeadscaleServiceServer).ListMachines(ctx, req.(*ListMachinesRequest))
+		return srv.(HeadscaleServiceServer).ListNodes(ctx, req.(*ListNodesRequest))
 	}
 	return interceptor(ctx, in, info, handler)
 }
 
-func _HeadscaleService_MoveMachine_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(MoveMachineRequest)
+func _HeadscaleService_MoveNode_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(MoveNodeRequest)
 	if err := dec(in); err != nil {
 		return nil, err
 	}
 	if interceptor == nil {
-		return srv.(HeadscaleServiceServer).MoveMachine(ctx, in)
+		return srv.(HeadscaleServiceServer).MoveNode(ctx, in)
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
-		FullMethod: HeadscaleService_MoveMachine_FullMethodName,
+		FullMethod: HeadscaleService_MoveNode_FullMethodName,
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(HeadscaleServiceServer).MoveMachine(ctx, req.(*MoveMachineRequest))
+		return srv.(HeadscaleServiceServer).MoveNode(ctx, req.(*MoveNodeRequest))
 	}
 	return interceptor(ctx, in, info, handler)
 }
@@ -804,20 +804,20 @@ func _HeadscaleService_DisableRoute_Handler(srv interface{}, ctx context.Context
 	return interceptor(ctx, in, info, handler)
 }
 
-func _HeadscaleService_GetMachineRoutes_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(GetMachineRoutesRequest)
+func _HeadscaleService_GetNodeRoutes_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(GetNodeRoutesRequest)
 	if err := dec(in); err != nil {
 		return nil, err
 	}
 	if interceptor == nil {
-		return srv.(HeadscaleServiceServer).GetMachineRoutes(ctx, in)
+		return srv.(HeadscaleServiceServer).GetNodeRoutes(ctx, in)
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
-		FullMethod: HeadscaleService_GetMachineRoutes_FullMethodName,
+		FullMethod: HeadscaleService_GetNodeRoutes_FullMethodName,
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(HeadscaleServiceServer).GetMachineRoutes(ctx, req.(*GetMachineRoutesRequest))
+		return srv.(HeadscaleServiceServer).GetNodeRoutes(ctx, req.(*GetNodeRoutesRequest))
 	}
 	return interceptor(ctx, in, info, handler)
 }
@@ -934,40 +934,40 @@ var HeadscaleService_ServiceDesc = grpc.ServiceDesc{
 			Handler:    _HeadscaleService_ListPreAuthKeys_Handler,
 		},
 		{
-			MethodName: "DebugCreateMachine",
-			Handler:    _HeadscaleService_DebugCreateMachine_Handler,
+			MethodName: "DebugCreateNode",
+			Handler:    _HeadscaleService_DebugCreateNode_Handler,
 		},
 		{
-			MethodName: "GetMachine",
-			Handler:    _HeadscaleService_GetMachine_Handler,
+			MethodName: "GetNode",
+			Handler:    _HeadscaleService_GetNode_Handler,
 		},
 		{
 			MethodName: "SetTags",
 			Handler:    _HeadscaleService_SetTags_Handler,
 		},
 		{
-			MethodName: "RegisterMachine",
-			Handler:    _HeadscaleService_RegisterMachine_Handler,
+			MethodName: "RegisterNode",
+			Handler:    _HeadscaleService_RegisterNode_Handler,
 		},
 		{
-			MethodName: "DeleteMachine",
-			Handler:    _HeadscaleService_DeleteMachine_Handler,
+			MethodName: "DeleteNode",
+			Handler:    _HeadscaleService_DeleteNode_Handler,
 		},
 		{
-			MethodName: "ExpireMachine",
-			Handler:    _HeadscaleService_ExpireMachine_Handler,
+			MethodName: "ExpireNode",
+			Handler:    _HeadscaleService_ExpireNode_Handler,
 		},
 		{
-			MethodName: "RenameMachine",
-			Handler:    _HeadscaleService_RenameMachine_Handler,
+			MethodName: "RenameNode",
+			Handler:    _HeadscaleService_RenameNode_Handler,
 		},
 		{
-			MethodName: "ListMachines",
-			Handler:    _HeadscaleService_ListMachines_Handler,
+			MethodName: "ListNodes",
+			Handler:    _HeadscaleService_ListNodes_Handler,
 		},
 		{
-			MethodName: "MoveMachine",
-			Handler:    _HeadscaleService_MoveMachine_Handler,
+			MethodName: "MoveNode",
+			Handler:    _HeadscaleService_MoveNode_Handler,
 		},
 		{
 			MethodName: "GetRoutes",
@@ -982,8 +982,8 @@ var HeadscaleService_ServiceDesc = grpc.ServiceDesc{
 			Handler:    _HeadscaleService_DisableRoute_Handler,
 		},
 		{
-			MethodName: "GetMachineRoutes",
-			Handler:    _HeadscaleService_GetMachineRoutes_Handler,
+			MethodName: "GetNodeRoutes",
+			Handler:    _HeadscaleService_GetNodeRoutes_Handler,
 		},
 		{
 			MethodName: "DeleteRoute",
diff --git a/gen/go/headscale/v1/machine.pb.go b/gen/go/headscale/v1/machine.pb.go
deleted file mode 100644
index c6b70dfb82..0000000000
--- a/gen/go/headscale/v1/machine.pb.go
+++ /dev/null
@@ -1,1618 +0,0 @@
-// Code generated by protoc-gen-go. DO NOT EDIT.
-// versions:
-// 	protoc-gen-go v1.29.1
-// 	protoc        (unknown)
-// source: headscale/v1/machine.proto
-
-package v1
-
-import (
-	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
-	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
-	timestamppb "google.golang.org/protobuf/types/known/timestamppb"
-	reflect "reflect"
-	sync "sync"
-)
-
-const (
-	// Verify that this generated code is sufficiently up-to-date.
-	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
-	// Verify that runtime/protoimpl is sufficiently up-to-date.
-	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
-)
-
-type RegisterMethod int32
-
-const (
-	RegisterMethod_REGISTER_METHOD_UNSPECIFIED RegisterMethod = 0
-	RegisterMethod_REGISTER_METHOD_AUTH_KEY    RegisterMethod = 1
-	RegisterMethod_REGISTER_METHOD_CLI         RegisterMethod = 2
-	RegisterMethod_REGISTER_METHOD_OIDC        RegisterMethod = 3
-)
-
-// Enum value maps for RegisterMethod.
-var (
-	RegisterMethod_name = map[int32]string{
-		0: "REGISTER_METHOD_UNSPECIFIED",
-		1: "REGISTER_METHOD_AUTH_KEY",
-		2: "REGISTER_METHOD_CLI",
-		3: "REGISTER_METHOD_OIDC",
-	}
-	RegisterMethod_value = map[string]int32{
-		"REGISTER_METHOD_UNSPECIFIED": 0,
-		"REGISTER_METHOD_AUTH_KEY":    1,
-		"REGISTER_METHOD_CLI":         2,
-		"REGISTER_METHOD_OIDC":        3,
-	}
-)
-
-func (x RegisterMethod) Enum() *RegisterMethod {
-	p := new(RegisterMethod)
-	*p = x
-	return p
-}
-
-func (x RegisterMethod) String() string {
-	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
-}
-
-func (RegisterMethod) Descriptor() protoreflect.EnumDescriptor {
-	return file_headscale_v1_machine_proto_enumTypes[0].Descriptor()
-}
-
-func (RegisterMethod) Type() protoreflect.EnumType {
-	return &file_headscale_v1_machine_proto_enumTypes[0]
-}
-
-func (x RegisterMethod) Number() protoreflect.EnumNumber {
-	return protoreflect.EnumNumber(x)
-}
-
-// Deprecated: Use RegisterMethod.Descriptor instead.
-func (RegisterMethod) EnumDescriptor() ([]byte, []int) {
-	return file_headscale_v1_machine_proto_rawDescGZIP(), []int{0}
-}
-
-type Machine struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	Id                   uint64                 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
-	MachineKey           string                 `protobuf:"bytes,2,opt,name=machine_key,json=machineKey,proto3" json:"machine_key,omitempty"`
-	NodeKey              string                 `protobuf:"bytes,3,opt,name=node_key,json=nodeKey,proto3" json:"node_key,omitempty"`
-	DiscoKey             string                 `protobuf:"bytes,4,opt,name=disco_key,json=discoKey,proto3" json:"disco_key,omitempty"`
-	IpAddresses          []string               `protobuf:"bytes,5,rep,name=ip_addresses,json=ipAddresses,proto3" json:"ip_addresses,omitempty"`
-	Name                 string                 `protobuf:"bytes,6,opt,name=name,proto3" json:"name,omitempty"`
-	User                 *User                  `protobuf:"bytes,7,opt,name=user,proto3" json:"user,omitempty"`
-	LastSeen             *timestamppb.Timestamp `protobuf:"bytes,8,opt,name=last_seen,json=lastSeen,proto3" json:"last_seen,omitempty"`
-	LastSuccessfulUpdate *timestamppb.Timestamp `protobuf:"bytes,9,opt,name=last_successful_update,json=lastSuccessfulUpdate,proto3" json:"last_successful_update,omitempty"`
-	Expiry               *timestamppb.Timestamp `protobuf:"bytes,10,opt,name=expiry,proto3" json:"expiry,omitempty"`
-	PreAuthKey           *PreAuthKey            `protobuf:"bytes,11,opt,name=pre_auth_key,json=preAuthKey,proto3" json:"pre_auth_key,omitempty"`
-	CreatedAt            *timestamppb.Timestamp `protobuf:"bytes,12,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"`
-	RegisterMethod       RegisterMethod         `protobuf:"varint,13,opt,name=register_method,json=registerMethod,proto3,enum=headscale.v1.RegisterMethod" json:"register_method,omitempty"`
-	ForcedTags           []string               `protobuf:"bytes,18,rep,name=forced_tags,json=forcedTags,proto3" json:"forced_tags,omitempty"`
-	InvalidTags          []string               `protobuf:"bytes,19,rep,name=invalid_tags,json=invalidTags,proto3" json:"invalid_tags,omitempty"`
-	ValidTags            []string               `protobuf:"bytes,20,rep,name=valid_tags,json=validTags,proto3" json:"valid_tags,omitempty"`
-	GivenName            string                 `protobuf:"bytes,21,opt,name=given_name,json=givenName,proto3" json:"given_name,omitempty"`
-	Online               bool                   `protobuf:"varint,22,opt,name=online,proto3" json:"online,omitempty"`
-}
-
-func (x *Machine) Reset() {
-	*x = Machine{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_headscale_v1_machine_proto_msgTypes[0]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *Machine) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*Machine) ProtoMessage() {}
-
-func (x *Machine) ProtoReflect() protoreflect.Message {
-	mi := &file_headscale_v1_machine_proto_msgTypes[0]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use Machine.ProtoReflect.Descriptor instead.
-func (*Machine) Descriptor() ([]byte, []int) {
-	return file_headscale_v1_machine_proto_rawDescGZIP(), []int{0}
-}
-
-func (x *Machine) GetId() uint64 {
-	if x != nil {
-		return x.Id
-	}
-	return 0
-}
-
-func (x *Machine) GetMachineKey() string {
-	if x != nil {
-		return x.MachineKey
-	}
-	return ""
-}
-
-func (x *Machine) GetNodeKey() string {
-	if x != nil {
-		return x.NodeKey
-	}
-	return ""
-}
-
-func (x *Machine) GetDiscoKey() string {
-	if x != nil {
-		return x.DiscoKey
-	}
-	return ""
-}
-
-func (x *Machine) GetIpAddresses() []string {
-	if x != nil {
-		return x.IpAddresses
-	}
-	return nil
-}
-
-func (x *Machine) GetName() string {
-	if x != nil {
-		return x.Name
-	}
-	return ""
-}
-
-func (x *Machine) GetUser() *User {
-	if x != nil {
-		return x.User
-	}
-	return nil
-}
-
-func (x *Machine) GetLastSeen() *timestamppb.Timestamp {
-	if x != nil {
-		return x.LastSeen
-	}
-	return nil
-}
-
-func (x *Machine) GetLastSuccessfulUpdate() *timestamppb.Timestamp {
-	if x != nil {
-		return x.LastSuccessfulUpdate
-	}
-	return nil
-}
-
-func (x *Machine) GetExpiry() *timestamppb.Timestamp {
-	if x != nil {
-		return x.Expiry
-	}
-	return nil
-}
-
-func (x *Machine) GetPreAuthKey() *PreAuthKey {
-	if x != nil {
-		return x.PreAuthKey
-	}
-	return nil
-}
-
-func (x *Machine) GetCreatedAt() *timestamppb.Timestamp {
-	if x != nil {
-		return x.CreatedAt
-	}
-	return nil
-}
-
-func (x *Machine) GetRegisterMethod() RegisterMethod {
-	if x != nil {
-		return x.RegisterMethod
-	}
-	return RegisterMethod_REGISTER_METHOD_UNSPECIFIED
-}
-
-func (x *Machine) GetForcedTags() []string {
-	if x != nil {
-		return x.ForcedTags
-	}
-	return nil
-}
-
-func (x *Machine) GetInvalidTags() []string {
-	if x != nil {
-		return x.InvalidTags
-	}
-	return nil
-}
-
-func (x *Machine) GetValidTags() []string {
-	if x != nil {
-		return x.ValidTags
-	}
-	return nil
-}
-
-func (x *Machine) GetGivenName() string {
-	if x != nil {
-		return x.GivenName
-	}
-	return ""
-}
-
-func (x *Machine) GetOnline() bool {
-	if x != nil {
-		return x.Online
-	}
-	return false
-}
-
-type RegisterMachineRequest struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	User string `protobuf:"bytes,1,opt,name=user,proto3" json:"user,omitempty"`
-	Key  string `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"`
-}
-
-func (x *RegisterMachineRequest) Reset() {
-	*x = RegisterMachineRequest{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_headscale_v1_machine_proto_msgTypes[1]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *RegisterMachineRequest) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*RegisterMachineRequest) ProtoMessage() {}
-
-func (x *RegisterMachineRequest) ProtoReflect() protoreflect.Message {
-	mi := &file_headscale_v1_machine_proto_msgTypes[1]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use RegisterMachineRequest.ProtoReflect.Descriptor instead.
-func (*RegisterMachineRequest) Descriptor() ([]byte, []int) {
-	return file_headscale_v1_machine_proto_rawDescGZIP(), []int{1}
-}
-
-func (x *RegisterMachineRequest) GetUser() string {
-	if x != nil {
-		return x.User
-	}
-	return ""
-}
-
-func (x *RegisterMachineRequest) GetKey() string {
-	if x != nil {
-		return x.Key
-	}
-	return ""
-}
-
-type RegisterMachineResponse struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	Machine *Machine `protobuf:"bytes,1,opt,name=machine,proto3" json:"machine,omitempty"`
-}
-
-func (x *RegisterMachineResponse) Reset() {
-	*x = RegisterMachineResponse{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_headscale_v1_machine_proto_msgTypes[2]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *RegisterMachineResponse) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*RegisterMachineResponse) ProtoMessage() {}
-
-func (x *RegisterMachineResponse) ProtoReflect() protoreflect.Message {
-	mi := &file_headscale_v1_machine_proto_msgTypes[2]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use RegisterMachineResponse.ProtoReflect.Descriptor instead.
-func (*RegisterMachineResponse) Descriptor() ([]byte, []int) {
-	return file_headscale_v1_machine_proto_rawDescGZIP(), []int{2}
-}
-
-func (x *RegisterMachineResponse) GetMachine() *Machine {
-	if x != nil {
-		return x.Machine
-	}
-	return nil
-}
-
-type GetMachineRequest struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	MachineId uint64 `protobuf:"varint,1,opt,name=machine_id,json=machineId,proto3" json:"machine_id,omitempty"`
-}
-
-func (x *GetMachineRequest) Reset() {
-	*x = GetMachineRequest{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_headscale_v1_machine_proto_msgTypes[3]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *GetMachineRequest) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*GetMachineRequest) ProtoMessage() {}
-
-func (x *GetMachineRequest) ProtoReflect() protoreflect.Message {
-	mi := &file_headscale_v1_machine_proto_msgTypes[3]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use GetMachineRequest.ProtoReflect.Descriptor instead.
-func (*GetMachineRequest) Descriptor() ([]byte, []int) {
-	return file_headscale_v1_machine_proto_rawDescGZIP(), []int{3}
-}
-
-func (x *GetMachineRequest) GetMachineId() uint64 {
-	if x != nil {
-		return x.MachineId
-	}
-	return 0
-}
-
-type GetMachineResponse struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	Machine *Machine `protobuf:"bytes,1,opt,name=machine,proto3" json:"machine,omitempty"`
-}
-
-func (x *GetMachineResponse) Reset() {
-	*x = GetMachineResponse{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_headscale_v1_machine_proto_msgTypes[4]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *GetMachineResponse) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*GetMachineResponse) ProtoMessage() {}
-
-func (x *GetMachineResponse) ProtoReflect() protoreflect.Message {
-	mi := &file_headscale_v1_machine_proto_msgTypes[4]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use GetMachineResponse.ProtoReflect.Descriptor instead.
-func (*GetMachineResponse) Descriptor() ([]byte, []int) {
-	return file_headscale_v1_machine_proto_rawDescGZIP(), []int{4}
-}
-
-func (x *GetMachineResponse) GetMachine() *Machine {
-	if x != nil {
-		return x.Machine
-	}
-	return nil
-}
-
-type SetTagsRequest struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	MachineId uint64   `protobuf:"varint,1,opt,name=machine_id,json=machineId,proto3" json:"machine_id,omitempty"`
-	Tags      []string `protobuf:"bytes,2,rep,name=tags,proto3" json:"tags,omitempty"`
-}
-
-func (x *SetTagsRequest) Reset() {
-	*x = SetTagsRequest{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_headscale_v1_machine_proto_msgTypes[5]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *SetTagsRequest) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*SetTagsRequest) ProtoMessage() {}
-
-func (x *SetTagsRequest) ProtoReflect() protoreflect.Message {
-	mi := &file_headscale_v1_machine_proto_msgTypes[5]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use SetTagsRequest.ProtoReflect.Descriptor instead.
-func (*SetTagsRequest) Descriptor() ([]byte, []int) {
-	return file_headscale_v1_machine_proto_rawDescGZIP(), []int{5}
-}
-
-func (x *SetTagsRequest) GetMachineId() uint64 {
-	if x != nil {
-		return x.MachineId
-	}
-	return 0
-}
-
-func (x *SetTagsRequest) GetTags() []string {
-	if x != nil {
-		return x.Tags
-	}
-	return nil
-}
-
-type SetTagsResponse struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	Machine *Machine `protobuf:"bytes,1,opt,name=machine,proto3" json:"machine,omitempty"`
-}
-
-func (x *SetTagsResponse) Reset() {
-	*x = SetTagsResponse{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_headscale_v1_machine_proto_msgTypes[6]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *SetTagsResponse) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*SetTagsResponse) ProtoMessage() {}
-
-func (x *SetTagsResponse) ProtoReflect() protoreflect.Message {
-	mi := &file_headscale_v1_machine_proto_msgTypes[6]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use SetTagsResponse.ProtoReflect.Descriptor instead.
-func (*SetTagsResponse) Descriptor() ([]byte, []int) {
-	return file_headscale_v1_machine_proto_rawDescGZIP(), []int{6}
-}
-
-func (x *SetTagsResponse) GetMachine() *Machine {
-	if x != nil {
-		return x.Machine
-	}
-	return nil
-}
-
-type DeleteMachineRequest struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	MachineId uint64 `protobuf:"varint,1,opt,name=machine_id,json=machineId,proto3" json:"machine_id,omitempty"`
-}
-
-func (x *DeleteMachineRequest) Reset() {
-	*x = DeleteMachineRequest{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_headscale_v1_machine_proto_msgTypes[7]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *DeleteMachineRequest) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*DeleteMachineRequest) ProtoMessage() {}
-
-func (x *DeleteMachineRequest) ProtoReflect() protoreflect.Message {
-	mi := &file_headscale_v1_machine_proto_msgTypes[7]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use DeleteMachineRequest.ProtoReflect.Descriptor instead.
-func (*DeleteMachineRequest) Descriptor() ([]byte, []int) {
-	return file_headscale_v1_machine_proto_rawDescGZIP(), []int{7}
-}
-
-func (x *DeleteMachineRequest) GetMachineId() uint64 {
-	if x != nil {
-		return x.MachineId
-	}
-	return 0
-}
-
-type DeleteMachineResponse struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-}
-
-func (x *DeleteMachineResponse) Reset() {
-	*x = DeleteMachineResponse{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_headscale_v1_machine_proto_msgTypes[8]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *DeleteMachineResponse) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*DeleteMachineResponse) ProtoMessage() {}
-
-func (x *DeleteMachineResponse) ProtoReflect() protoreflect.Message {
-	mi := &file_headscale_v1_machine_proto_msgTypes[8]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use DeleteMachineResponse.ProtoReflect.Descriptor instead.
-func (*DeleteMachineResponse) Descriptor() ([]byte, []int) {
-	return file_headscale_v1_machine_proto_rawDescGZIP(), []int{8}
-}
-
-type ExpireMachineRequest struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	MachineId uint64 `protobuf:"varint,1,opt,name=machine_id,json=machineId,proto3" json:"machine_id,omitempty"`
-}
-
-func (x *ExpireMachineRequest) Reset() {
-	*x = ExpireMachineRequest{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_headscale_v1_machine_proto_msgTypes[9]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *ExpireMachineRequest) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*ExpireMachineRequest) ProtoMessage() {}
-
-func (x *ExpireMachineRequest) ProtoReflect() protoreflect.Message {
-	mi := &file_headscale_v1_machine_proto_msgTypes[9]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use ExpireMachineRequest.ProtoReflect.Descriptor instead.
-func (*ExpireMachineRequest) Descriptor() ([]byte, []int) {
-	return file_headscale_v1_machine_proto_rawDescGZIP(), []int{9}
-}
-
-func (x *ExpireMachineRequest) GetMachineId() uint64 {
-	if x != nil {
-		return x.MachineId
-	}
-	return 0
-}
-
-type ExpireMachineResponse struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	Machine *Machine `protobuf:"bytes,1,opt,name=machine,proto3" json:"machine,omitempty"`
-}
-
-func (x *ExpireMachineResponse) Reset() {
-	*x = ExpireMachineResponse{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_headscale_v1_machine_proto_msgTypes[10]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *ExpireMachineResponse) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*ExpireMachineResponse) ProtoMessage() {}
-
-func (x *ExpireMachineResponse) ProtoReflect() protoreflect.Message {
-	mi := &file_headscale_v1_machine_proto_msgTypes[10]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use ExpireMachineResponse.ProtoReflect.Descriptor instead.
-func (*ExpireMachineResponse) Descriptor() ([]byte, []int) {
-	return file_headscale_v1_machine_proto_rawDescGZIP(), []int{10}
-}
-
-func (x *ExpireMachineResponse) GetMachine() *Machine {
-	if x != nil {
-		return x.Machine
-	}
-	return nil
-}
-
-type RenameMachineRequest struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	MachineId uint64 `protobuf:"varint,1,opt,name=machine_id,json=machineId,proto3" json:"machine_id,omitempty"`
-	NewName   string `protobuf:"bytes,2,opt,name=new_name,json=newName,proto3" json:"new_name,omitempty"`
-}
-
-func (x *RenameMachineRequest) Reset() {
-	*x = RenameMachineRequest{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_headscale_v1_machine_proto_msgTypes[11]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *RenameMachineRequest) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*RenameMachineRequest) ProtoMessage() {}
-
-func (x *RenameMachineRequest) ProtoReflect() protoreflect.Message {
-	mi := &file_headscale_v1_machine_proto_msgTypes[11]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use RenameMachineRequest.ProtoReflect.Descriptor instead.
-func (*RenameMachineRequest) Descriptor() ([]byte, []int) {
-	return file_headscale_v1_machine_proto_rawDescGZIP(), []int{11}
-}
-
-func (x *RenameMachineRequest) GetMachineId() uint64 {
-	if x != nil {
-		return x.MachineId
-	}
-	return 0
-}
-
-func (x *RenameMachineRequest) GetNewName() string {
-	if x != nil {
-		return x.NewName
-	}
-	return ""
-}
-
-type RenameMachineResponse struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	Machine *Machine `protobuf:"bytes,1,opt,name=machine,proto3" json:"machine,omitempty"`
-}
-
-func (x *RenameMachineResponse) Reset() {
-	*x = RenameMachineResponse{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_headscale_v1_machine_proto_msgTypes[12]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *RenameMachineResponse) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*RenameMachineResponse) ProtoMessage() {}
-
-func (x *RenameMachineResponse) ProtoReflect() protoreflect.Message {
-	mi := &file_headscale_v1_machine_proto_msgTypes[12]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use RenameMachineResponse.ProtoReflect.Descriptor instead.
-func (*RenameMachineResponse) Descriptor() ([]byte, []int) {
-	return file_headscale_v1_machine_proto_rawDescGZIP(), []int{12}
-}
-
-func (x *RenameMachineResponse) GetMachine() *Machine {
-	if x != nil {
-		return x.Machine
-	}
-	return nil
-}
-
-type ListMachinesRequest struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	User string `protobuf:"bytes,1,opt,name=user,proto3" json:"user,omitempty"`
-}
-
-func (x *ListMachinesRequest) Reset() {
-	*x = ListMachinesRequest{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_headscale_v1_machine_proto_msgTypes[13]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *ListMachinesRequest) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*ListMachinesRequest) ProtoMessage() {}
-
-func (x *ListMachinesRequest) ProtoReflect() protoreflect.Message {
-	mi := &file_headscale_v1_machine_proto_msgTypes[13]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use ListMachinesRequest.ProtoReflect.Descriptor instead.
-func (*ListMachinesRequest) Descriptor() ([]byte, []int) {
-	return file_headscale_v1_machine_proto_rawDescGZIP(), []int{13}
-}
-
-func (x *ListMachinesRequest) GetUser() string {
-	if x != nil {
-		return x.User
-	}
-	return ""
-}
-
-type ListMachinesResponse struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	Machines []*Machine `protobuf:"bytes,1,rep,name=machines,proto3" json:"machines,omitempty"`
-}
-
-func (x *ListMachinesResponse) Reset() {
-	*x = ListMachinesResponse{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_headscale_v1_machine_proto_msgTypes[14]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *ListMachinesResponse) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*ListMachinesResponse) ProtoMessage() {}
-
-func (x *ListMachinesResponse) ProtoReflect() protoreflect.Message {
-	mi := &file_headscale_v1_machine_proto_msgTypes[14]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use ListMachinesResponse.ProtoReflect.Descriptor instead.
-func (*ListMachinesResponse) Descriptor() ([]byte, []int) {
-	return file_headscale_v1_machine_proto_rawDescGZIP(), []int{14}
-}
-
-func (x *ListMachinesResponse) GetMachines() []*Machine {
-	if x != nil {
-		return x.Machines
-	}
-	return nil
-}
-
-type MoveMachineRequest struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	MachineId uint64 `protobuf:"varint,1,opt,name=machine_id,json=machineId,proto3" json:"machine_id,omitempty"`
-	User      string `protobuf:"bytes,2,opt,name=user,proto3" json:"user,omitempty"`
-}
-
-func (x *MoveMachineRequest) Reset() {
-	*x = MoveMachineRequest{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_headscale_v1_machine_proto_msgTypes[15]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *MoveMachineRequest) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*MoveMachineRequest) ProtoMessage() {}
-
-func (x *MoveMachineRequest) ProtoReflect() protoreflect.Message {
-	mi := &file_headscale_v1_machine_proto_msgTypes[15]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use MoveMachineRequest.ProtoReflect.Descriptor instead.
-func (*MoveMachineRequest) Descriptor() ([]byte, []int) {
-	return file_headscale_v1_machine_proto_rawDescGZIP(), []int{15}
-}
-
-func (x *MoveMachineRequest) GetMachineId() uint64 {
-	if x != nil {
-		return x.MachineId
-	}
-	return 0
-}
-
-func (x *MoveMachineRequest) GetUser() string {
-	if x != nil {
-		return x.User
-	}
-	return ""
-}
-
-type MoveMachineResponse struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	Machine *Machine `protobuf:"bytes,1,opt,name=machine,proto3" json:"machine,omitempty"`
-}
-
-func (x *MoveMachineResponse) Reset() {
-	*x = MoveMachineResponse{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_headscale_v1_machine_proto_msgTypes[16]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *MoveMachineResponse) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*MoveMachineResponse) ProtoMessage() {}
-
-func (x *MoveMachineResponse) ProtoReflect() protoreflect.Message {
-	mi := &file_headscale_v1_machine_proto_msgTypes[16]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use MoveMachineResponse.ProtoReflect.Descriptor instead.
-func (*MoveMachineResponse) Descriptor() ([]byte, []int) {
-	return file_headscale_v1_machine_proto_rawDescGZIP(), []int{16}
-}
-
-func (x *MoveMachineResponse) GetMachine() *Machine {
-	if x != nil {
-		return x.Machine
-	}
-	return nil
-}
-
-type DebugCreateMachineRequest struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	User   string   `protobuf:"bytes,1,opt,name=user,proto3" json:"user,omitempty"`
-	Key    string   `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"`
-	Name   string   `protobuf:"bytes,3,opt,name=name,proto3" json:"name,omitempty"`
-	Routes []string `protobuf:"bytes,4,rep,name=routes,proto3" json:"routes,omitempty"`
-}
-
-func (x *DebugCreateMachineRequest) Reset() {
-	*x = DebugCreateMachineRequest{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_headscale_v1_machine_proto_msgTypes[17]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *DebugCreateMachineRequest) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*DebugCreateMachineRequest) ProtoMessage() {}
-
-func (x *DebugCreateMachineRequest) ProtoReflect() protoreflect.Message {
-	mi := &file_headscale_v1_machine_proto_msgTypes[17]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use DebugCreateMachineRequest.ProtoReflect.Descriptor instead.
-func (*DebugCreateMachineRequest) Descriptor() ([]byte, []int) {
-	return file_headscale_v1_machine_proto_rawDescGZIP(), []int{17}
-}
-
-func (x *DebugCreateMachineRequest) GetUser() string {
-	if x != nil {
-		return x.User
-	}
-	return ""
-}
-
-func (x *DebugCreateMachineRequest) GetKey() string {
-	if x != nil {
-		return x.Key
-	}
-	return ""
-}
-
-func (x *DebugCreateMachineRequest) GetName() string {
-	if x != nil {
-		return x.Name
-	}
-	return ""
-}
-
-func (x *DebugCreateMachineRequest) GetRoutes() []string {
-	if x != nil {
-		return x.Routes
-	}
-	return nil
-}
-
-type DebugCreateMachineResponse struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	Machine *Machine `protobuf:"bytes,1,opt,name=machine,proto3" json:"machine,omitempty"`
-}
-
-func (x *DebugCreateMachineResponse) Reset() {
-	*x = DebugCreateMachineResponse{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_headscale_v1_machine_proto_msgTypes[18]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *DebugCreateMachineResponse) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*DebugCreateMachineResponse) ProtoMessage() {}
-
-func (x *DebugCreateMachineResponse) ProtoReflect() protoreflect.Message {
-	mi := &file_headscale_v1_machine_proto_msgTypes[18]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use DebugCreateMachineResponse.ProtoReflect.Descriptor instead.
-func (*DebugCreateMachineResponse) Descriptor() ([]byte, []int) {
-	return file_headscale_v1_machine_proto_rawDescGZIP(), []int{18}
-}
-
-func (x *DebugCreateMachineResponse) GetMachine() *Machine {
-	if x != nil {
-		return x.Machine
-	}
-	return nil
-}
-
-var File_headscale_v1_machine_proto protoreflect.FileDescriptor
-
-var file_headscale_v1_machine_proto_rawDesc = []byte{
-	0x0a, 0x1a, 0x68, 0x65, 0x61, 0x64, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x2f, 0x76, 0x31, 0x2f, 0x6d,
-	0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x0c, 0x68, 0x65,
-	0x61, 0x64, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x2e, 0x76, 0x31, 0x1a, 0x1f, 0x67, 0x6f, 0x6f, 0x67,
-	0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x69, 0x6d, 0x65,
-	0x73, 0x74, 0x61, 0x6d, 0x70, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x17, 0x68, 0x65, 0x61,
-	0x64, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x2f, 0x76, 0x31, 0x2f, 0x75, 0x73, 0x65, 0x72, 0x2e, 0x70,
-	0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1d, 0x68, 0x65, 0x61, 0x64, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x2f,
-	0x76, 0x31, 0x2f, 0x70, 0x72, 0x65, 0x61, 0x75, 0x74, 0x68, 0x6b, 0x65, 0x79, 0x2e, 0x70, 0x72,
-	0x6f, 0x74, 0x6f, 0x22, 0xee, 0x05, 0x0a, 0x07, 0x4d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x12,
-	0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x02, 0x69, 0x64, 0x12,
-	0x1f, 0x0a, 0x0b, 0x6d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x02,
-	0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x6d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x4b, 0x65, 0x79,
-	0x12, 0x19, 0x0a, 0x08, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x03, 0x20, 0x01,
-	0x28, 0x09, 0x52, 0x07, 0x6e, 0x6f, 0x64, 0x65, 0x4b, 0x65, 0x79, 0x12, 0x1b, 0x0a, 0x09, 0x64,
-	0x69, 0x73, 0x63, 0x6f, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08,
-	0x64, 0x69, 0x73, 0x63, 0x6f, 0x4b, 0x65, 0x79, 0x12, 0x21, 0x0a, 0x0c, 0x69, 0x70, 0x5f, 0x61,
-	0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x18, 0x05, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0b,
-	0x69, 0x70, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x12, 0x12, 0x0a, 0x04, 0x6e,
-	0x61, 0x6d, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12,
-	0x26, 0x0a, 0x04, 0x75, 0x73, 0x65, 0x72, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e,
-	0x68, 0x65, 0x61, 0x64, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x55, 0x73, 0x65,
-	0x72, 0x52, 0x04, 0x75, 0x73, 0x65, 0x72, 0x12, 0x37, 0x0a, 0x09, 0x6c, 0x61, 0x73, 0x74, 0x5f,
-	0x73, 0x65, 0x65, 0x6e, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f,
-	0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d,
-	0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x08, 0x6c, 0x61, 0x73, 0x74, 0x53, 0x65, 0x65, 0x6e,
-	0x12, 0x50, 0x0a, 0x16, 0x6c, 0x61, 0x73, 0x74, 0x5f, 0x73, 0x75, 0x63, 0x63, 0x65, 0x73, 0x73,
-	0x66, 0x75, 0x6c, 0x5f, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0b,
-	0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62,
-	0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x14, 0x6c, 0x61,
-	0x73, 0x74, 0x53, 0x75, 0x63, 0x63, 0x65, 0x73, 0x73, 0x66, 0x75, 0x6c, 0x55, 0x70, 0x64, 0x61,
-	0x74, 0x65, 0x12, 0x32, 0x0a, 0x06, 0x65, 0x78, 0x70, 0x69, 0x72, 0x79, 0x18, 0x0a, 0x20, 0x01,
-	0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74,
-	0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x06,
-	0x65, 0x78, 0x70, 0x69, 0x72, 0x79, 0x12, 0x3a, 0x0a, 0x0c, 0x70, 0x72, 0x65, 0x5f, 0x61, 0x75,
-	0x74, 0x68, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x68,
-	0x65, 0x61, 0x64, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x72, 0x65, 0x41,
-	0x75, 0x74, 0x68, 0x4b, 0x65, 0x79, 0x52, 0x0a, 0x70, 0x72, 0x65, 0x41, 0x75, 0x74, 0x68, 0x4b,
-	0x65, 0x79, 0x12, 0x39, 0x0a, 0x0a, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x61, 0x74,
-	0x18, 0x0c, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e,
-	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61,
-	0x6d, 0x70, 0x52, 0x09, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x41, 0x74, 0x12, 0x45, 0x0a,
-	0x0f, 0x72, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x5f, 0x6d, 0x65, 0x74, 0x68, 0x6f, 0x64,
-	0x18, 0x0d, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1c, 0x2e, 0x68, 0x65, 0x61, 0x64, 0x73, 0x63, 0x61,
-	0x6c, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x4d, 0x65,
-	0x74, 0x68, 0x6f, 0x64, 0x52, 0x0e, 0x72, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x4d, 0x65,
-	0x74, 0x68, 0x6f, 0x64, 0x12, 0x1f, 0x0a, 0x0b, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x64, 0x5f, 0x74,
-	0x61, 0x67, 0x73, 0x18, 0x12, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x6f, 0x72, 0x63, 0x65,
-	0x64, 0x54, 0x61, 0x67, 0x73, 0x12, 0x21, 0x0a, 0x0c, 0x69, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64,
-	0x5f, 0x74, 0x61, 0x67, 0x73, 0x18, 0x13, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0b, 0x69, 0x6e, 0x76,
-	0x61, 0x6c, 0x69, 0x64, 0x54, 0x61, 0x67, 0x73, 0x12, 0x1d, 0x0a, 0x0a, 0x76, 0x61, 0x6c, 0x69,
-	0x64, 0x5f, 0x74, 0x61, 0x67, 0x73, 0x18, 0x14, 0x20, 0x03, 0x28, 0x09, 0x52, 0x09, 0x76, 0x61,
-	0x6c, 0x69, 0x64, 0x54, 0x61, 0x67, 0x73, 0x12, 0x1d, 0x0a, 0x0a, 0x67, 0x69, 0x76, 0x65, 0x6e,
-	0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x15, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x67, 0x69, 0x76,
-	0x65, 0x6e, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x6f, 0x6e, 0x6c, 0x69, 0x6e, 0x65,
-	0x18, 0x16, 0x20, 0x01, 0x28, 0x08, 0x52, 0x06, 0x6f, 0x6e, 0x6c, 0x69, 0x6e, 0x65, 0x4a, 0x04,
-	0x08, 0x0e, 0x10, 0x12, 0x22, 0x3e, 0x0a, 0x16, 0x52, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72,
-	0x4d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x12,
-	0x0a, 0x04, 0x75, 0x73, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x75, 0x73,
-	0x65, 0x72, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52,
-	0x03, 0x6b, 0x65, 0x79, 0x22, 0x4a, 0x0a, 0x17, 0x52, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72,
-	0x4d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12,
-	0x2f, 0x0a, 0x07, 0x6d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b,
-	0x32, 0x15, 0x2e, 0x68, 0x65, 0x61, 0x64, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x2e, 0x76, 0x31, 0x2e,
-	0x4d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x52, 0x07, 0x6d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65,
-	0x22, 0x32, 0x0a, 0x11, 0x47, 0x65, 0x74, 0x4d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x52, 0x65,
-	0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1d, 0x0a, 0x0a, 0x6d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65,
-	0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x09, 0x6d, 0x61, 0x63, 0x68, 0x69,
-	0x6e, 0x65, 0x49, 0x64, 0x22, 0x45, 0x0a, 0x12, 0x47, 0x65, 0x74, 0x4d, 0x61, 0x63, 0x68, 0x69,
-	0x6e, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x2f, 0x0a, 0x07, 0x6d, 0x61,
-	0x63, 0x68, 0x69, 0x6e, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x68, 0x65,
-	0x61, 0x64, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x4d, 0x61, 0x63, 0x68, 0x69,
-	0x6e, 0x65, 0x52, 0x07, 0x6d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x22, 0x43, 0x0a, 0x0e, 0x53,
-	0x65, 0x74, 0x54, 0x61, 0x67, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1d, 0x0a,
-	0x0a, 0x6d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28,
-	0x04, 0x52, 0x09, 0x6d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x49, 0x64, 0x12, 0x12, 0x0a, 0x04,
-	0x74, 0x61, 0x67, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x09, 0x52, 0x04, 0x74, 0x61, 0x67, 0x73,
-	0x22, 0x42, 0x0a, 0x0f, 0x53, 0x65, 0x74, 0x54, 0x61, 0x67, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f,
-	0x6e, 0x73, 0x65, 0x12, 0x2f, 0x0a, 0x07, 0x6d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x18, 0x01,
-	0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x68, 0x65, 0x61, 0x64, 0x73, 0x63, 0x61, 0x6c, 0x65,
-	0x2e, 0x76, 0x31, 0x2e, 0x4d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x52, 0x07, 0x6d, 0x61, 0x63,
-	0x68, 0x69, 0x6e, 0x65, 0x22, 0x35, 0x0a, 0x14, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x4d, 0x61,
-	0x63, 0x68, 0x69, 0x6e, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1d, 0x0a, 0x0a,
-	0x6d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04,
-	0x52, 0x09, 0x6d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x49, 0x64, 0x22, 0x17, 0x0a, 0x15, 0x44,
-	0x65, 0x6c, 0x65, 0x74, 0x65, 0x4d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x52, 0x65, 0x73, 0x70,
-	0x6f, 0x6e, 0x73, 0x65, 0x22, 0x35, 0x0a, 0x14, 0x45, 0x78, 0x70, 0x69, 0x72, 0x65, 0x4d, 0x61,
-	0x63, 0x68, 0x69, 0x6e, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1d, 0x0a, 0x0a,
-	0x6d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04,
-	0x52, 0x09, 0x6d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x49, 0x64, 0x22, 0x48, 0x0a, 0x15, 0x45,
-	0x78, 0x70, 0x69, 0x72, 0x65, 0x4d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x52, 0x65, 0x73, 0x70,
-	0x6f, 0x6e, 0x73, 0x65, 0x12, 0x2f, 0x0a, 0x07, 0x6d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x18,
-	0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x68, 0x65, 0x61, 0x64, 0x73, 0x63, 0x61, 0x6c,
-	0x65, 0x2e, 0x76, 0x31, 0x2e, 0x4d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x52, 0x07, 0x6d, 0x61,
-	0x63, 0x68, 0x69, 0x6e, 0x65, 0x22, 0x50, 0x0a, 0x14, 0x52, 0x65, 0x6e, 0x61, 0x6d, 0x65, 0x4d,
-	0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1d, 0x0a,
-	0x0a, 0x6d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28,
-	0x04, 0x52, 0x09, 0x6d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x49, 0x64, 0x12, 0x19, 0x0a, 0x08,
-	0x6e, 0x65, 0x77, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07,
-	0x6e, 0x65, 0x77, 0x4e, 0x61, 0x6d, 0x65, 0x22, 0x48, 0x0a, 0x15, 0x52, 0x65, 0x6e, 0x61, 0x6d,
-	0x65, 0x4d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
-	0x12, 0x2f, 0x0a, 0x07, 0x6d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28,
-	0x0b, 0x32, 0x15, 0x2e, 0x68, 0x65, 0x61, 0x64, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x2e, 0x76, 0x31,
-	0x2e, 0x4d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x52, 0x07, 0x6d, 0x61, 0x63, 0x68, 0x69, 0x6e,
-	0x65, 0x22, 0x29, 0x0a, 0x13, 0x4c, 0x69, 0x73, 0x74, 0x4d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65,
-	0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x75, 0x73, 0x65, 0x72,
-	0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x75, 0x73, 0x65, 0x72, 0x22, 0x49, 0x0a, 0x14,
-	0x4c, 0x69, 0x73, 0x74, 0x4d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70,
-	0x6f, 0x6e, 0x73, 0x65, 0x12, 0x31, 0x0a, 0x08, 0x6d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x73,
-	0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x68, 0x65, 0x61, 0x64, 0x73, 0x63, 0x61,
-	0x6c, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x4d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x52, 0x08, 0x6d,
-	0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x73, 0x22, 0x47, 0x0a, 0x12, 0x4d, 0x6f, 0x76, 0x65, 0x4d,
-	0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1d, 0x0a,
-	0x0a, 0x6d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28,
-	0x04, 0x52, 0x09, 0x6d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x49, 0x64, 0x12, 0x12, 0x0a, 0x04,
-	0x75, 0x73, 0x65, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x75, 0x73, 0x65, 0x72,
-	0x22, 0x46, 0x0a, 0x13, 0x4d, 0x6f, 0x76, 0x65, 0x4d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x52,
-	0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x2f, 0x0a, 0x07, 0x6d, 0x61, 0x63, 0x68, 0x69,
-	0x6e, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x68, 0x65, 0x61, 0x64, 0x73,
-	0x63, 0x61, 0x6c, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x4d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x52,
-	0x07, 0x6d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x22, 0x6d, 0x0a, 0x19, 0x44, 0x65, 0x62, 0x75,
-	0x67, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x4d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x52, 0x65,
-	0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x75, 0x73, 0x65, 0x72, 0x18, 0x01, 0x20,
-	0x01, 0x28, 0x09, 0x52, 0x04, 0x75, 0x73, 0x65, 0x72, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79,
-	0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x12, 0x0a, 0x04, 0x6e,
-	0x61, 0x6d, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12,
-	0x16, 0x0a, 0x06, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x73, 0x18, 0x04, 0x20, 0x03, 0x28, 0x09, 0x52,
-	0x06, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x73, 0x22, 0x4d, 0x0a, 0x1a, 0x44, 0x65, 0x62, 0x75, 0x67,
-	0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x4d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x52, 0x65, 0x73,
-	0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x2f, 0x0a, 0x07, 0x6d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65,
-	0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x68, 0x65, 0x61, 0x64, 0x73, 0x63, 0x61,
-	0x6c, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x4d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x52, 0x07, 0x6d,
-	0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x2a, 0x82, 0x01, 0x0a, 0x0e, 0x52, 0x65, 0x67, 0x69, 0x73,
-	0x74, 0x65, 0x72, 0x4d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x12, 0x1f, 0x0a, 0x1b, 0x52, 0x45, 0x47,
-	0x49, 0x53, 0x54, 0x45, 0x52, 0x5f, 0x4d, 0x45, 0x54, 0x48, 0x4f, 0x44, 0x5f, 0x55, 0x4e, 0x53,
-	0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, 0x1c, 0x0a, 0x18, 0x52, 0x45,
-	0x47, 0x49, 0x53, 0x54, 0x45, 0x52, 0x5f, 0x4d, 0x45, 0x54, 0x48, 0x4f, 0x44, 0x5f, 0x41, 0x55,
-	0x54, 0x48, 0x5f, 0x4b, 0x45, 0x59, 0x10, 0x01, 0x12, 0x17, 0x0a, 0x13, 0x52, 0x45, 0x47, 0x49,
-	0x53, 0x54, 0x45, 0x52, 0x5f, 0x4d, 0x45, 0x54, 0x48, 0x4f, 0x44, 0x5f, 0x43, 0x4c, 0x49, 0x10,
-	0x02, 0x12, 0x18, 0x0a, 0x14, 0x52, 0x45, 0x47, 0x49, 0x53, 0x54, 0x45, 0x52, 0x5f, 0x4d, 0x45,
-	0x54, 0x48, 0x4f, 0x44, 0x5f, 0x4f, 0x49, 0x44, 0x43, 0x10, 0x03, 0x42, 0x29, 0x5a, 0x27, 0x67,
-	0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x6a, 0x75, 0x61, 0x6e, 0x66, 0x6f,
-	0x6e, 0x74, 0x2f, 0x68, 0x65, 0x61, 0x64, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x2f, 0x67, 0x65, 0x6e,
-	0x2f, 0x67, 0x6f, 0x2f, 0x76, 0x31, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
-}
-
-var (
-	file_headscale_v1_machine_proto_rawDescOnce sync.Once
-	file_headscale_v1_machine_proto_rawDescData = file_headscale_v1_machine_proto_rawDesc
-)
-
-func file_headscale_v1_machine_proto_rawDescGZIP() []byte {
-	file_headscale_v1_machine_proto_rawDescOnce.Do(func() {
-		file_headscale_v1_machine_proto_rawDescData = protoimpl.X.CompressGZIP(file_headscale_v1_machine_proto_rawDescData)
-	})
-	return file_headscale_v1_machine_proto_rawDescData
-}
-
-var file_headscale_v1_machine_proto_enumTypes = make([]protoimpl.EnumInfo, 1)
-var file_headscale_v1_machine_proto_msgTypes = make([]protoimpl.MessageInfo, 19)
-var file_headscale_v1_machine_proto_goTypes = []interface{}{
-	(RegisterMethod)(0),                // 0: headscale.v1.RegisterMethod
-	(*Machine)(nil),                    // 1: headscale.v1.Machine
-	(*RegisterMachineRequest)(nil),     // 2: headscale.v1.RegisterMachineRequest
-	(*RegisterMachineResponse)(nil),    // 3: headscale.v1.RegisterMachineResponse
-	(*GetMachineRequest)(nil),          // 4: headscale.v1.GetMachineRequest
-	(*GetMachineResponse)(nil),         // 5: headscale.v1.GetMachineResponse
-	(*SetTagsRequest)(nil),             // 6: headscale.v1.SetTagsRequest
-	(*SetTagsResponse)(nil),            // 7: headscale.v1.SetTagsResponse
-	(*DeleteMachineRequest)(nil),       // 8: headscale.v1.DeleteMachineRequest
-	(*DeleteMachineResponse)(nil),      // 9: headscale.v1.DeleteMachineResponse
-	(*ExpireMachineRequest)(nil),       // 10: headscale.v1.ExpireMachineRequest
-	(*ExpireMachineResponse)(nil),      // 11: headscale.v1.ExpireMachineResponse
-	(*RenameMachineRequest)(nil),       // 12: headscale.v1.RenameMachineRequest
-	(*RenameMachineResponse)(nil),      // 13: headscale.v1.RenameMachineResponse
-	(*ListMachinesRequest)(nil),        // 14: headscale.v1.ListMachinesRequest
-	(*ListMachinesResponse)(nil),       // 15: headscale.v1.ListMachinesResponse
-	(*MoveMachineRequest)(nil),         // 16: headscale.v1.MoveMachineRequest
-	(*MoveMachineResponse)(nil),        // 17: headscale.v1.MoveMachineResponse
-	(*DebugCreateMachineRequest)(nil),  // 18: headscale.v1.DebugCreateMachineRequest
-	(*DebugCreateMachineResponse)(nil), // 19: headscale.v1.DebugCreateMachineResponse
-	(*User)(nil),                       // 20: headscale.v1.User
-	(*timestamppb.Timestamp)(nil),      // 21: google.protobuf.Timestamp
-	(*PreAuthKey)(nil),                 // 22: headscale.v1.PreAuthKey
-}
-var file_headscale_v1_machine_proto_depIdxs = []int32{
-	20, // 0: headscale.v1.Machine.user:type_name -> headscale.v1.User
-	21, // 1: headscale.v1.Machine.last_seen:type_name -> google.protobuf.Timestamp
-	21, // 2: headscale.v1.Machine.last_successful_update:type_name -> google.protobuf.Timestamp
-	21, // 3: headscale.v1.Machine.expiry:type_name -> google.protobuf.Timestamp
-	22, // 4: headscale.v1.Machine.pre_auth_key:type_name -> headscale.v1.PreAuthKey
-	21, // 5: headscale.v1.Machine.created_at:type_name -> google.protobuf.Timestamp
-	0,  // 6: headscale.v1.Machine.register_method:type_name -> headscale.v1.RegisterMethod
-	1,  // 7: headscale.v1.RegisterMachineResponse.machine:type_name -> headscale.v1.Machine
-	1,  // 8: headscale.v1.GetMachineResponse.machine:type_name -> headscale.v1.Machine
-	1,  // 9: headscale.v1.SetTagsResponse.machine:type_name -> headscale.v1.Machine
-	1,  // 10: headscale.v1.ExpireMachineResponse.machine:type_name -> headscale.v1.Machine
-	1,  // 11: headscale.v1.RenameMachineResponse.machine:type_name -> headscale.v1.Machine
-	1,  // 12: headscale.v1.ListMachinesResponse.machines:type_name -> headscale.v1.Machine
-	1,  // 13: headscale.v1.MoveMachineResponse.machine:type_name -> headscale.v1.Machine
-	1,  // 14: headscale.v1.DebugCreateMachineResponse.machine:type_name -> headscale.v1.Machine
-	15, // [15:15] is the sub-list for method output_type
-	15, // [15:15] is the sub-list for method input_type
-	15, // [15:15] is the sub-list for extension type_name
-	15, // [15:15] is the sub-list for extension extendee
-	0,  // [0:15] is the sub-list for field type_name
-}
-
-func init() { file_headscale_v1_machine_proto_init() }
-func file_headscale_v1_machine_proto_init() {
-	if File_headscale_v1_machine_proto != nil {
-		return
-	}
-	file_headscale_v1_user_proto_init()
-	file_headscale_v1_preauthkey_proto_init()
-	if !protoimpl.UnsafeEnabled {
-		file_headscale_v1_machine_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*Machine); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-		file_headscale_v1_machine_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*RegisterMachineRequest); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-		file_headscale_v1_machine_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*RegisterMachineResponse); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-		file_headscale_v1_machine_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*GetMachineRequest); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-		file_headscale_v1_machine_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*GetMachineResponse); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-		file_headscale_v1_machine_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*SetTagsRequest); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-		file_headscale_v1_machine_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*SetTagsResponse); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-		file_headscale_v1_machine_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*DeleteMachineRequest); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-		file_headscale_v1_machine_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*DeleteMachineResponse); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-		file_headscale_v1_machine_proto_msgTypes[9].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*ExpireMachineRequest); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-		file_headscale_v1_machine_proto_msgTypes[10].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*ExpireMachineResponse); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-		file_headscale_v1_machine_proto_msgTypes[11].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*RenameMachineRequest); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-		file_headscale_v1_machine_proto_msgTypes[12].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*RenameMachineResponse); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-		file_headscale_v1_machine_proto_msgTypes[13].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*ListMachinesRequest); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-		file_headscale_v1_machine_proto_msgTypes[14].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*ListMachinesResponse); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-		file_headscale_v1_machine_proto_msgTypes[15].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*MoveMachineRequest); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-		file_headscale_v1_machine_proto_msgTypes[16].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*MoveMachineResponse); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-		file_headscale_v1_machine_proto_msgTypes[17].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*DebugCreateMachineRequest); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-		file_headscale_v1_machine_proto_msgTypes[18].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*DebugCreateMachineResponse); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-	}
-	type x struct{}
-	out := protoimpl.TypeBuilder{
-		File: protoimpl.DescBuilder{
-			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
-			RawDescriptor: file_headscale_v1_machine_proto_rawDesc,
-			NumEnums:      1,
-			NumMessages:   19,
-			NumExtensions: 0,
-			NumServices:   0,
-		},
-		GoTypes:           file_headscale_v1_machine_proto_goTypes,
-		DependencyIndexes: file_headscale_v1_machine_proto_depIdxs,
-		EnumInfos:         file_headscale_v1_machine_proto_enumTypes,
-		MessageInfos:      file_headscale_v1_machine_proto_msgTypes,
-	}.Build()
-	File_headscale_v1_machine_proto = out.File
-	file_headscale_v1_machine_proto_rawDesc = nil
-	file_headscale_v1_machine_proto_goTypes = nil
-	file_headscale_v1_machine_proto_depIdxs = nil
-}
diff --git a/gen/go/headscale/v1/node.pb.go b/gen/go/headscale/v1/node.pb.go
new file mode 100644
index 0000000000..e567d3cad2
--- /dev/null
+++ b/gen/go/headscale/v1/node.pb.go
@@ -0,0 +1,1608 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// versions:
+// 	protoc-gen-go v1.31.0
+// 	protoc        (unknown)
+// source: headscale/v1/node.proto
+
+package v1
+
+import (
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	timestamppb "google.golang.org/protobuf/types/known/timestamppb"
+	reflect "reflect"
+	sync "sync"
+)
+
+const (
+	// Verify that this generated code is sufficiently up-to-date.
+	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
+	// Verify that runtime/protoimpl is sufficiently up-to-date.
+	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
+)
+
+type RegisterMethod int32
+
+const (
+	RegisterMethod_REGISTER_METHOD_UNSPECIFIED RegisterMethod = 0
+	RegisterMethod_REGISTER_METHOD_AUTH_KEY    RegisterMethod = 1
+	RegisterMethod_REGISTER_METHOD_CLI         RegisterMethod = 2
+	RegisterMethod_REGISTER_METHOD_OIDC        RegisterMethod = 3
+)
+
+// Enum value maps for RegisterMethod.
+var (
+	RegisterMethod_name = map[int32]string{
+		0: "REGISTER_METHOD_UNSPECIFIED",
+		1: "REGISTER_METHOD_AUTH_KEY",
+		2: "REGISTER_METHOD_CLI",
+		3: "REGISTER_METHOD_OIDC",
+	}
+	RegisterMethod_value = map[string]int32{
+		"REGISTER_METHOD_UNSPECIFIED": 0,
+		"REGISTER_METHOD_AUTH_KEY":    1,
+		"REGISTER_METHOD_CLI":         2,
+		"REGISTER_METHOD_OIDC":        3,
+	}
+)
+
+func (x RegisterMethod) Enum() *RegisterMethod {
+	p := new(RegisterMethod)
+	*p = x
+	return p
+}
+
+func (x RegisterMethod) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (RegisterMethod) Descriptor() protoreflect.EnumDescriptor {
+	return file_headscale_v1_node_proto_enumTypes[0].Descriptor()
+}
+
+func (RegisterMethod) Type() protoreflect.EnumType {
+	return &file_headscale_v1_node_proto_enumTypes[0]
+}
+
+func (x RegisterMethod) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Use RegisterMethod.Descriptor instead.
+func (RegisterMethod) EnumDescriptor() ([]byte, []int) {
+	return file_headscale_v1_node_proto_rawDescGZIP(), []int{0}
+}
+
+type Node struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Id                   uint64                 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
+	MachineKey           string                 `protobuf:"bytes,2,opt,name=machine_key,json=machineKey,proto3" json:"machine_key,omitempty"`
+	NodeKey              string                 `protobuf:"bytes,3,opt,name=node_key,json=nodeKey,proto3" json:"node_key,omitempty"`
+	DiscoKey             string                 `protobuf:"bytes,4,opt,name=disco_key,json=discoKey,proto3" json:"disco_key,omitempty"`
+	IpAddresses          []string               `protobuf:"bytes,5,rep,name=ip_addresses,json=ipAddresses,proto3" json:"ip_addresses,omitempty"`
+	Name                 string                 `protobuf:"bytes,6,opt,name=name,proto3" json:"name,omitempty"`
+	User                 *User                  `protobuf:"bytes,7,opt,name=user,proto3" json:"user,omitempty"`
+	LastSeen             *timestamppb.Timestamp `protobuf:"bytes,8,opt,name=last_seen,json=lastSeen,proto3" json:"last_seen,omitempty"`
+	LastSuccessfulUpdate *timestamppb.Timestamp `protobuf:"bytes,9,opt,name=last_successful_update,json=lastSuccessfulUpdate,proto3" json:"last_successful_update,omitempty"`
+	Expiry               *timestamppb.Timestamp `protobuf:"bytes,10,opt,name=expiry,proto3" json:"expiry,omitempty"`
+	PreAuthKey           *PreAuthKey            `protobuf:"bytes,11,opt,name=pre_auth_key,json=preAuthKey,proto3" json:"pre_auth_key,omitempty"`
+	CreatedAt            *timestamppb.Timestamp `protobuf:"bytes,12,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"`
+	RegisterMethod       RegisterMethod         `protobuf:"varint,13,opt,name=register_method,json=registerMethod,proto3,enum=headscale.v1.RegisterMethod" json:"register_method,omitempty"`
+	ForcedTags           []string               `protobuf:"bytes,18,rep,name=forced_tags,json=forcedTags,proto3" json:"forced_tags,omitempty"`
+	InvalidTags          []string               `protobuf:"bytes,19,rep,name=invalid_tags,json=invalidTags,proto3" json:"invalid_tags,omitempty"`
+	ValidTags            []string               `protobuf:"bytes,20,rep,name=valid_tags,json=validTags,proto3" json:"valid_tags,omitempty"`
+	GivenName            string                 `protobuf:"bytes,21,opt,name=given_name,json=givenName,proto3" json:"given_name,omitempty"`
+	Online               bool                   `protobuf:"varint,22,opt,name=online,proto3" json:"online,omitempty"`
+}
+
+func (x *Node) Reset() {
+	*x = Node{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_headscale_v1_node_proto_msgTypes[0]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Node) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Node) ProtoMessage() {}
+
+func (x *Node) ProtoReflect() protoreflect.Message {
+	mi := &file_headscale_v1_node_proto_msgTypes[0]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Node.ProtoReflect.Descriptor instead.
+func (*Node) Descriptor() ([]byte, []int) {
+	return file_headscale_v1_node_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *Node) GetId() uint64 {
+	if x != nil {
+		return x.Id
+	}
+	return 0
+}
+
+func (x *Node) GetMachineKey() string {
+	if x != nil {
+		return x.MachineKey
+	}
+	return ""
+}
+
+func (x *Node) GetNodeKey() string {
+	if x != nil {
+		return x.NodeKey
+	}
+	return ""
+}
+
+func (x *Node) GetDiscoKey() string {
+	if x != nil {
+		return x.DiscoKey
+	}
+	return ""
+}
+
+func (x *Node) GetIpAddresses() []string {
+	if x != nil {
+		return x.IpAddresses
+	}
+	return nil
+}
+
+func (x *Node) GetName() string {
+	if x != nil {
+		return x.Name
+	}
+	return ""
+}
+
+func (x *Node) GetUser() *User {
+	if x != nil {
+		return x.User
+	}
+	return nil
+}
+
+func (x *Node) GetLastSeen() *timestamppb.Timestamp {
+	if x != nil {
+		return x.LastSeen
+	}
+	return nil
+}
+
+func (x *Node) GetLastSuccessfulUpdate() *timestamppb.Timestamp {
+	if x != nil {
+		return x.LastSuccessfulUpdate
+	}
+	return nil
+}
+
+func (x *Node) GetExpiry() *timestamppb.Timestamp {
+	if x != nil {
+		return x.Expiry
+	}
+	return nil
+}
+
+func (x *Node) GetPreAuthKey() *PreAuthKey {
+	if x != nil {
+		return x.PreAuthKey
+	}
+	return nil
+}
+
+func (x *Node) GetCreatedAt() *timestamppb.Timestamp {
+	if x != nil {
+		return x.CreatedAt
+	}
+	return nil
+}
+
+func (x *Node) GetRegisterMethod() RegisterMethod {
+	if x != nil {
+		return x.RegisterMethod
+	}
+	return RegisterMethod_REGISTER_METHOD_UNSPECIFIED
+}
+
+func (x *Node) GetForcedTags() []string {
+	if x != nil {
+		return x.ForcedTags
+	}
+	return nil
+}
+
+func (x *Node) GetInvalidTags() []string {
+	if x != nil {
+		return x.InvalidTags
+	}
+	return nil
+}
+
+func (x *Node) GetValidTags() []string {
+	if x != nil {
+		return x.ValidTags
+	}
+	return nil
+}
+
+func (x *Node) GetGivenName() string {
+	if x != nil {
+		return x.GivenName
+	}
+	return ""
+}
+
+func (x *Node) GetOnline() bool {
+	if x != nil {
+		return x.Online
+	}
+	return false
+}
+
+type RegisterNodeRequest struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	User string `protobuf:"bytes,1,opt,name=user,proto3" json:"user,omitempty"`
+	Key  string `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"`
+}
+
+func (x *RegisterNodeRequest) Reset() {
+	*x = RegisterNodeRequest{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_headscale_v1_node_proto_msgTypes[1]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *RegisterNodeRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*RegisterNodeRequest) ProtoMessage() {}
+
+func (x *RegisterNodeRequest) ProtoReflect() protoreflect.Message {
+	mi := &file_headscale_v1_node_proto_msgTypes[1]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use RegisterNodeRequest.ProtoReflect.Descriptor instead.
+func (*RegisterNodeRequest) Descriptor() ([]byte, []int) {
+	return file_headscale_v1_node_proto_rawDescGZIP(), []int{1}
+}
+
+func (x *RegisterNodeRequest) GetUser() string {
+	if x != nil {
+		return x.User
+	}
+	return ""
+}
+
+func (x *RegisterNodeRequest) GetKey() string {
+	if x != nil {
+		return x.Key
+	}
+	return ""
+}
+
+type RegisterNodeResponse struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Node *Node `protobuf:"bytes,1,opt,name=node,proto3" json:"node,omitempty"`
+}
+
+func (x *RegisterNodeResponse) Reset() {
+	*x = RegisterNodeResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_headscale_v1_node_proto_msgTypes[2]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *RegisterNodeResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*RegisterNodeResponse) ProtoMessage() {}
+
+func (x *RegisterNodeResponse) ProtoReflect() protoreflect.Message {
+	mi := &file_headscale_v1_node_proto_msgTypes[2]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use RegisterNodeResponse.ProtoReflect.Descriptor instead.
+func (*RegisterNodeResponse) Descriptor() ([]byte, []int) {
+	return file_headscale_v1_node_proto_rawDescGZIP(), []int{2}
+}
+
+func (x *RegisterNodeResponse) GetNode() *Node {
+	if x != nil {
+		return x.Node
+	}
+	return nil
+}
+
+type GetNodeRequest struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	NodeId uint64 `protobuf:"varint,1,opt,name=node_id,json=nodeId,proto3" json:"node_id,omitempty"`
+}
+
+func (x *GetNodeRequest) Reset() {
+	*x = GetNodeRequest{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_headscale_v1_node_proto_msgTypes[3]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *GetNodeRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*GetNodeRequest) ProtoMessage() {}
+
+func (x *GetNodeRequest) ProtoReflect() protoreflect.Message {
+	mi := &file_headscale_v1_node_proto_msgTypes[3]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use GetNodeRequest.ProtoReflect.Descriptor instead.
+func (*GetNodeRequest) Descriptor() ([]byte, []int) {
+	return file_headscale_v1_node_proto_rawDescGZIP(), []int{3}
+}
+
+func (x *GetNodeRequest) GetNodeId() uint64 {
+	if x != nil {
+		return x.NodeId
+	}
+	return 0
+}
+
+type GetNodeResponse struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Node *Node `protobuf:"bytes,1,opt,name=node,proto3" json:"node,omitempty"`
+}
+
+func (x *GetNodeResponse) Reset() {
+	*x = GetNodeResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_headscale_v1_node_proto_msgTypes[4]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *GetNodeResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*GetNodeResponse) ProtoMessage() {}
+
+func (x *GetNodeResponse) ProtoReflect() protoreflect.Message {
+	mi := &file_headscale_v1_node_proto_msgTypes[4]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use GetNodeResponse.ProtoReflect.Descriptor instead.
+func (*GetNodeResponse) Descriptor() ([]byte, []int) {
+	return file_headscale_v1_node_proto_rawDescGZIP(), []int{4}
+}
+
+func (x *GetNodeResponse) GetNode() *Node {
+	if x != nil {
+		return x.Node
+	}
+	return nil
+}
+
+type SetTagsRequest struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	NodeId uint64   `protobuf:"varint,1,opt,name=node_id,json=nodeId,proto3" json:"node_id,omitempty"`
+	Tags   []string `protobuf:"bytes,2,rep,name=tags,proto3" json:"tags,omitempty"`
+}
+
+func (x *SetTagsRequest) Reset() {
+	*x = SetTagsRequest{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_headscale_v1_node_proto_msgTypes[5]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *SetTagsRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*SetTagsRequest) ProtoMessage() {}
+
+func (x *SetTagsRequest) ProtoReflect() protoreflect.Message {
+	mi := &file_headscale_v1_node_proto_msgTypes[5]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use SetTagsRequest.ProtoReflect.Descriptor instead.
+func (*SetTagsRequest) Descriptor() ([]byte, []int) {
+	return file_headscale_v1_node_proto_rawDescGZIP(), []int{5}
+}
+
+func (x *SetTagsRequest) GetNodeId() uint64 {
+	if x != nil {
+		return x.NodeId
+	}
+	return 0
+}
+
+func (x *SetTagsRequest) GetTags() []string {
+	if x != nil {
+		return x.Tags
+	}
+	return nil
+}
+
+type SetTagsResponse struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Node *Node `protobuf:"bytes,1,opt,name=node,proto3" json:"node,omitempty"`
+}
+
+func (x *SetTagsResponse) Reset() {
+	*x = SetTagsResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_headscale_v1_node_proto_msgTypes[6]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *SetTagsResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*SetTagsResponse) ProtoMessage() {}
+
+func (x *SetTagsResponse) ProtoReflect() protoreflect.Message {
+	mi := &file_headscale_v1_node_proto_msgTypes[6]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use SetTagsResponse.ProtoReflect.Descriptor instead.
+func (*SetTagsResponse) Descriptor() ([]byte, []int) {
+	return file_headscale_v1_node_proto_rawDescGZIP(), []int{6}
+}
+
+func (x *SetTagsResponse) GetNode() *Node {
+	if x != nil {
+		return x.Node
+	}
+	return nil
+}
+
+type DeleteNodeRequest struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	NodeId uint64 `protobuf:"varint,1,opt,name=node_id,json=nodeId,proto3" json:"node_id,omitempty"`
+}
+
+func (x *DeleteNodeRequest) Reset() {
+	*x = DeleteNodeRequest{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_headscale_v1_node_proto_msgTypes[7]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *DeleteNodeRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*DeleteNodeRequest) ProtoMessage() {}
+
+func (x *DeleteNodeRequest) ProtoReflect() protoreflect.Message {
+	mi := &file_headscale_v1_node_proto_msgTypes[7]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use DeleteNodeRequest.ProtoReflect.Descriptor instead.
+func (*DeleteNodeRequest) Descriptor() ([]byte, []int) {
+	return file_headscale_v1_node_proto_rawDescGZIP(), []int{7}
+}
+
+func (x *DeleteNodeRequest) GetNodeId() uint64 {
+	if x != nil {
+		return x.NodeId
+	}
+	return 0
+}
+
+type DeleteNodeResponse struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *DeleteNodeResponse) Reset() {
+	*x = DeleteNodeResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_headscale_v1_node_proto_msgTypes[8]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *DeleteNodeResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*DeleteNodeResponse) ProtoMessage() {}
+
+func (x *DeleteNodeResponse) ProtoReflect() protoreflect.Message {
+	mi := &file_headscale_v1_node_proto_msgTypes[8]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use DeleteNodeResponse.ProtoReflect.Descriptor instead.
+func (*DeleteNodeResponse) Descriptor() ([]byte, []int) {
+	return file_headscale_v1_node_proto_rawDescGZIP(), []int{8}
+}
+
+type ExpireNodeRequest struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	NodeId uint64 `protobuf:"varint,1,opt,name=node_id,json=nodeId,proto3" json:"node_id,omitempty"`
+}
+
+func (x *ExpireNodeRequest) Reset() {
+	*x = ExpireNodeRequest{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_headscale_v1_node_proto_msgTypes[9]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *ExpireNodeRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*ExpireNodeRequest) ProtoMessage() {}
+
+func (x *ExpireNodeRequest) ProtoReflect() protoreflect.Message {
+	mi := &file_headscale_v1_node_proto_msgTypes[9]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use ExpireNodeRequest.ProtoReflect.Descriptor instead.
+func (*ExpireNodeRequest) Descriptor() ([]byte, []int) {
+	return file_headscale_v1_node_proto_rawDescGZIP(), []int{9}
+}
+
+func (x *ExpireNodeRequest) GetNodeId() uint64 {
+	if x != nil {
+		return x.NodeId
+	}
+	return 0
+}
+
+type ExpireNodeResponse struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Node *Node `protobuf:"bytes,1,opt,name=node,proto3" json:"node,omitempty"`
+}
+
+func (x *ExpireNodeResponse) Reset() {
+	*x = ExpireNodeResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_headscale_v1_node_proto_msgTypes[10]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *ExpireNodeResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*ExpireNodeResponse) ProtoMessage() {}
+
+func (x *ExpireNodeResponse) ProtoReflect() protoreflect.Message {
+	mi := &file_headscale_v1_node_proto_msgTypes[10]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use ExpireNodeResponse.ProtoReflect.Descriptor instead.
+func (*ExpireNodeResponse) Descriptor() ([]byte, []int) {
+	return file_headscale_v1_node_proto_rawDescGZIP(), []int{10}
+}
+
+func (x *ExpireNodeResponse) GetNode() *Node {
+	if x != nil {
+		return x.Node
+	}
+	return nil
+}
+
+type RenameNodeRequest struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	NodeId  uint64 `protobuf:"varint,1,opt,name=node_id,json=nodeId,proto3" json:"node_id,omitempty"`
+	NewName string `protobuf:"bytes,2,opt,name=new_name,json=newName,proto3" json:"new_name,omitempty"`
+}
+
+func (x *RenameNodeRequest) Reset() {
+	*x = RenameNodeRequest{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_headscale_v1_node_proto_msgTypes[11]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *RenameNodeRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*RenameNodeRequest) ProtoMessage() {}
+
+func (x *RenameNodeRequest) ProtoReflect() protoreflect.Message {
+	mi := &file_headscale_v1_node_proto_msgTypes[11]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use RenameNodeRequest.ProtoReflect.Descriptor instead.
+func (*RenameNodeRequest) Descriptor() ([]byte, []int) {
+	return file_headscale_v1_node_proto_rawDescGZIP(), []int{11}
+}
+
+func (x *RenameNodeRequest) GetNodeId() uint64 {
+	if x != nil {
+		return x.NodeId
+	}
+	return 0
+}
+
+func (x *RenameNodeRequest) GetNewName() string {
+	if x != nil {
+		return x.NewName
+	}
+	return ""
+}
+
+type RenameNodeResponse struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Node *Node `protobuf:"bytes,1,opt,name=node,proto3" json:"node,omitempty"`
+}
+
+func (x *RenameNodeResponse) Reset() {
+	*x = RenameNodeResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_headscale_v1_node_proto_msgTypes[12]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *RenameNodeResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*RenameNodeResponse) ProtoMessage() {}
+
+func (x *RenameNodeResponse) ProtoReflect() protoreflect.Message {
+	mi := &file_headscale_v1_node_proto_msgTypes[12]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use RenameNodeResponse.ProtoReflect.Descriptor instead.
+func (*RenameNodeResponse) Descriptor() ([]byte, []int) {
+	return file_headscale_v1_node_proto_rawDescGZIP(), []int{12}
+}
+
+func (x *RenameNodeResponse) GetNode() *Node {
+	if x != nil {
+		return x.Node
+	}
+	return nil
+}
+
+type ListNodesRequest struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	User string `protobuf:"bytes,1,opt,name=user,proto3" json:"user,omitempty"`
+}
+
+func (x *ListNodesRequest) Reset() {
+	*x = ListNodesRequest{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_headscale_v1_node_proto_msgTypes[13]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *ListNodesRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*ListNodesRequest) ProtoMessage() {}
+
+func (x *ListNodesRequest) ProtoReflect() protoreflect.Message {
+	mi := &file_headscale_v1_node_proto_msgTypes[13]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use ListNodesRequest.ProtoReflect.Descriptor instead.
+func (*ListNodesRequest) Descriptor() ([]byte, []int) {
+	return file_headscale_v1_node_proto_rawDescGZIP(), []int{13}
+}
+
+func (x *ListNodesRequest) GetUser() string {
+	if x != nil {
+		return x.User
+	}
+	return ""
+}
+
+type ListNodesResponse struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Nodes []*Node `protobuf:"bytes,1,rep,name=nodes,proto3" json:"nodes,omitempty"`
+}
+
+func (x *ListNodesResponse) Reset() {
+	*x = ListNodesResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_headscale_v1_node_proto_msgTypes[14]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *ListNodesResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*ListNodesResponse) ProtoMessage() {}
+
+func (x *ListNodesResponse) ProtoReflect() protoreflect.Message {
+	mi := &file_headscale_v1_node_proto_msgTypes[14]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use ListNodesResponse.ProtoReflect.Descriptor instead.
+func (*ListNodesResponse) Descriptor() ([]byte, []int) {
+	return file_headscale_v1_node_proto_rawDescGZIP(), []int{14}
+}
+
+func (x *ListNodesResponse) GetNodes() []*Node {
+	if x != nil {
+		return x.Nodes
+	}
+	return nil
+}
+
+type MoveNodeRequest struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	NodeId uint64 `protobuf:"varint,1,opt,name=node_id,json=nodeId,proto3" json:"node_id,omitempty"`
+	User   string `protobuf:"bytes,2,opt,name=user,proto3" json:"user,omitempty"`
+}
+
+func (x *MoveNodeRequest) Reset() {
+	*x = MoveNodeRequest{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_headscale_v1_node_proto_msgTypes[15]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *MoveNodeRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*MoveNodeRequest) ProtoMessage() {}
+
+func (x *MoveNodeRequest) ProtoReflect() protoreflect.Message {
+	mi := &file_headscale_v1_node_proto_msgTypes[15]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use MoveNodeRequest.ProtoReflect.Descriptor instead.
+func (*MoveNodeRequest) Descriptor() ([]byte, []int) {
+	return file_headscale_v1_node_proto_rawDescGZIP(), []int{15}
+}
+
+func (x *MoveNodeRequest) GetNodeId() uint64 {
+	if x != nil {
+		return x.NodeId
+	}
+	return 0
+}
+
+func (x *MoveNodeRequest) GetUser() string {
+	if x != nil {
+		return x.User
+	}
+	return ""
+}
+
+type MoveNodeResponse struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Node *Node `protobuf:"bytes,1,opt,name=node,proto3" json:"node,omitempty"`
+}
+
+func (x *MoveNodeResponse) Reset() {
+	*x = MoveNodeResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_headscale_v1_node_proto_msgTypes[16]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *MoveNodeResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*MoveNodeResponse) ProtoMessage() {}
+
+func (x *MoveNodeResponse) ProtoReflect() protoreflect.Message {
+	mi := &file_headscale_v1_node_proto_msgTypes[16]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use MoveNodeResponse.ProtoReflect.Descriptor instead.
+func (*MoveNodeResponse) Descriptor() ([]byte, []int) {
+	return file_headscale_v1_node_proto_rawDescGZIP(), []int{16}
+}
+
+func (x *MoveNodeResponse) GetNode() *Node {
+	if x != nil {
+		return x.Node
+	}
+	return nil
+}
+
+type DebugCreateNodeRequest struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	User   string   `protobuf:"bytes,1,opt,name=user,proto3" json:"user,omitempty"`
+	Key    string   `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"`
+	Name   string   `protobuf:"bytes,3,opt,name=name,proto3" json:"name,omitempty"`
+	Routes []string `protobuf:"bytes,4,rep,name=routes,proto3" json:"routes,omitempty"`
+}
+
+func (x *DebugCreateNodeRequest) Reset() {
+	*x = DebugCreateNodeRequest{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_headscale_v1_node_proto_msgTypes[17]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *DebugCreateNodeRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*DebugCreateNodeRequest) ProtoMessage() {}
+
+func (x *DebugCreateNodeRequest) ProtoReflect() protoreflect.Message {
+	mi := &file_headscale_v1_node_proto_msgTypes[17]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use DebugCreateNodeRequest.ProtoReflect.Descriptor instead.
+func (*DebugCreateNodeRequest) Descriptor() ([]byte, []int) {
+	return file_headscale_v1_node_proto_rawDescGZIP(), []int{17}
+}
+
+func (x *DebugCreateNodeRequest) GetUser() string {
+	if x != nil {
+		return x.User
+	}
+	return ""
+}
+
+func (x *DebugCreateNodeRequest) GetKey() string {
+	if x != nil {
+		return x.Key
+	}
+	return ""
+}
+
+func (x *DebugCreateNodeRequest) GetName() string {
+	if x != nil {
+		return x.Name
+	}
+	return ""
+}
+
+func (x *DebugCreateNodeRequest) GetRoutes() []string {
+	if x != nil {
+		return x.Routes
+	}
+	return nil
+}
+
+type DebugCreateNodeResponse struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Node *Node `protobuf:"bytes,1,opt,name=node,proto3" json:"node,omitempty"`
+}
+
+func (x *DebugCreateNodeResponse) Reset() {
+	*x = DebugCreateNodeResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_headscale_v1_node_proto_msgTypes[18]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *DebugCreateNodeResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*DebugCreateNodeResponse) ProtoMessage() {}
+
+func (x *DebugCreateNodeResponse) ProtoReflect() protoreflect.Message {
+	mi := &file_headscale_v1_node_proto_msgTypes[18]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use DebugCreateNodeResponse.ProtoReflect.Descriptor instead.
+func (*DebugCreateNodeResponse) Descriptor() ([]byte, []int) {
+	return file_headscale_v1_node_proto_rawDescGZIP(), []int{18}
+}
+
+func (x *DebugCreateNodeResponse) GetNode() *Node {
+	if x != nil {
+		return x.Node
+	}
+	return nil
+}
+
+var File_headscale_v1_node_proto protoreflect.FileDescriptor
+
+var file_headscale_v1_node_proto_rawDesc = []byte{
+	0x0a, 0x17, 0x68, 0x65, 0x61, 0x64, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x2f, 0x76, 0x31, 0x2f, 0x6e,
+	0x6f, 0x64, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x0c, 0x68, 0x65, 0x61, 0x64, 0x73,
+	0x63, 0x61, 0x6c, 0x65, 0x2e, 0x76, 0x31, 0x1a, 0x1f, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61,
+	0x6d, 0x70, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x17, 0x68, 0x65, 0x61, 0x64, 0x73, 0x63,
+	0x61, 0x6c, 0x65, 0x2f, 0x76, 0x31, 0x2f, 0x75, 0x73, 0x65, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x1a, 0x1d, 0x68, 0x65, 0x61, 0x64, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x2f, 0x76, 0x31, 0x2f,
+	0x70, 0x72, 0x65, 0x61, 0x75, 0x74, 0x68, 0x6b, 0x65, 0x79, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x22, 0xeb, 0x05, 0x0a, 0x04, 0x4e, 0x6f, 0x64, 0x65, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18,
+	0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x02, 0x69, 0x64, 0x12, 0x1f, 0x0a, 0x0b, 0x6d, 0x61, 0x63,
+	0x68, 0x69, 0x6e, 0x65, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a,
+	0x6d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x4b, 0x65, 0x79, 0x12, 0x19, 0x0a, 0x08, 0x6e, 0x6f,
+	0x64, 0x65, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6e, 0x6f,
+	0x64, 0x65, 0x4b, 0x65, 0x79, 0x12, 0x1b, 0x0a, 0x09, 0x64, 0x69, 0x73, 0x63, 0x6f, 0x5f, 0x6b,
+	0x65, 0x79, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x64, 0x69, 0x73, 0x63, 0x6f, 0x4b,
+	0x65, 0x79, 0x12, 0x21, 0x0a, 0x0c, 0x69, 0x70, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73,
+	0x65, 0x73, 0x18, 0x05, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0b, 0x69, 0x70, 0x41, 0x64, 0x64, 0x72,
+	0x65, 0x73, 0x73, 0x65, 0x73, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x06, 0x20,
+	0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x26, 0x0a, 0x04, 0x75, 0x73, 0x65,
+	0x72, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x68, 0x65, 0x61, 0x64, 0x73, 0x63,
+	0x61, 0x6c, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x55, 0x73, 0x65, 0x72, 0x52, 0x04, 0x75, 0x73, 0x65,
+	0x72, 0x12, 0x37, 0x0a, 0x09, 0x6c, 0x61, 0x73, 0x74, 0x5f, 0x73, 0x65, 0x65, 0x6e, 0x18, 0x08,
+	0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70,
+	0x52, 0x08, 0x6c, 0x61, 0x73, 0x74, 0x53, 0x65, 0x65, 0x6e, 0x12, 0x50, 0x0a, 0x16, 0x6c, 0x61,
+	0x73, 0x74, 0x5f, 0x73, 0x75, 0x63, 0x63, 0x65, 0x73, 0x73, 0x66, 0x75, 0x6c, 0x5f, 0x75, 0x70,
+	0x64, 0x61, 0x74, 0x65, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d,
+	0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x14, 0x6c, 0x61, 0x73, 0x74, 0x53, 0x75, 0x63, 0x63,
+	0x65, 0x73, 0x73, 0x66, 0x75, 0x6c, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x12, 0x32, 0x0a, 0x06,
+	0x65, 0x78, 0x70, 0x69, 0x72, 0x79, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67,
+	0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54,
+	0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x06, 0x65, 0x78, 0x70, 0x69, 0x72, 0x79,
+	0x12, 0x3a, 0x0a, 0x0c, 0x70, 0x72, 0x65, 0x5f, 0x61, 0x75, 0x74, 0x68, 0x5f, 0x6b, 0x65, 0x79,
+	0x18, 0x0b, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x68, 0x65, 0x61, 0x64, 0x73, 0x63, 0x61,
+	0x6c, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x72, 0x65, 0x41, 0x75, 0x74, 0x68, 0x4b, 0x65, 0x79,
+	0x52, 0x0a, 0x70, 0x72, 0x65, 0x41, 0x75, 0x74, 0x68, 0x4b, 0x65, 0x79, 0x12, 0x39, 0x0a, 0x0a,
+	0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x61, 0x74, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x0b,
+	0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62,
+	0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x09, 0x63, 0x72,
+	0x65, 0x61, 0x74, 0x65, 0x64, 0x41, 0x74, 0x12, 0x45, 0x0a, 0x0f, 0x72, 0x65, 0x67, 0x69, 0x73,
+	0x74, 0x65, 0x72, 0x5f, 0x6d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x0e,
+	0x32, 0x1c, 0x2e, 0x68, 0x65, 0x61, 0x64, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x2e, 0x76, 0x31, 0x2e,
+	0x52, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x4d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x52, 0x0e,
+	0x72, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x4d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x12, 0x1f,
+	0x0a, 0x0b, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x64, 0x5f, 0x74, 0x61, 0x67, 0x73, 0x18, 0x12, 0x20,
+	0x03, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x64, 0x54, 0x61, 0x67, 0x73, 0x12,
+	0x21, 0x0a, 0x0c, 0x69, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x5f, 0x74, 0x61, 0x67, 0x73, 0x18,
+	0x13, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0b, 0x69, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x54, 0x61,
+	0x67, 0x73, 0x12, 0x1d, 0x0a, 0x0a, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x5f, 0x74, 0x61, 0x67, 0x73,
+	0x18, 0x14, 0x20, 0x03, 0x28, 0x09, 0x52, 0x09, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x54, 0x61, 0x67,
+	0x73, 0x12, 0x1d, 0x0a, 0x0a, 0x67, 0x69, 0x76, 0x65, 0x6e, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18,
+	0x15, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x67, 0x69, 0x76, 0x65, 0x6e, 0x4e, 0x61, 0x6d, 0x65,
+	0x12, 0x16, 0x0a, 0x06, 0x6f, 0x6e, 0x6c, 0x69, 0x6e, 0x65, 0x18, 0x16, 0x20, 0x01, 0x28, 0x08,
+	0x52, 0x06, 0x6f, 0x6e, 0x6c, 0x69, 0x6e, 0x65, 0x4a, 0x04, 0x08, 0x0e, 0x10, 0x12, 0x22, 0x3b,
+	0x0a, 0x13, 0x52, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x4e, 0x6f, 0x64, 0x65, 0x52, 0x65,
+	0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x75, 0x73, 0x65, 0x72, 0x18, 0x01, 0x20,
+	0x01, 0x28, 0x09, 0x52, 0x04, 0x75, 0x73, 0x65, 0x72, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79,
+	0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x22, 0x3e, 0x0a, 0x14, 0x52,
+	0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x4e, 0x6f, 0x64, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f,
+	0x6e, 0x73, 0x65, 0x12, 0x26, 0x0a, 0x04, 0x6e, 0x6f, 0x64, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28,
+	0x0b, 0x32, 0x12, 0x2e, 0x68, 0x65, 0x61, 0x64, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x2e, 0x76, 0x31,
+	0x2e, 0x4e, 0x6f, 0x64, 0x65, 0x52, 0x04, 0x6e, 0x6f, 0x64, 0x65, 0x22, 0x29, 0x0a, 0x0e, 0x47,
+	0x65, 0x74, 0x4e, 0x6f, 0x64, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x17, 0x0a,
+	0x07, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x06,
+	0x6e, 0x6f, 0x64, 0x65, 0x49, 0x64, 0x22, 0x39, 0x0a, 0x0f, 0x47, 0x65, 0x74, 0x4e, 0x6f, 0x64,
+	0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x26, 0x0a, 0x04, 0x6e, 0x6f, 0x64,
+	0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x68, 0x65, 0x61, 0x64, 0x73, 0x63,
+	0x61, 0x6c, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x4e, 0x6f, 0x64, 0x65, 0x52, 0x04, 0x6e, 0x6f, 0x64,
+	0x65, 0x22, 0x3d, 0x0a, 0x0e, 0x53, 0x65, 0x74, 0x54, 0x61, 0x67, 0x73, 0x52, 0x65, 0x71, 0x75,
+	0x65, 0x73, 0x74, 0x12, 0x17, 0x0a, 0x07, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x69, 0x64, 0x18, 0x01,
+	0x20, 0x01, 0x28, 0x04, 0x52, 0x06, 0x6e, 0x6f, 0x64, 0x65, 0x49, 0x64, 0x12, 0x12, 0x0a, 0x04,
+	0x74, 0x61, 0x67, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x09, 0x52, 0x04, 0x74, 0x61, 0x67, 0x73,
+	0x22, 0x39, 0x0a, 0x0f, 0x53, 0x65, 0x74, 0x54, 0x61, 0x67, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f,
+	0x6e, 0x73, 0x65, 0x12, 0x26, 0x0a, 0x04, 0x6e, 0x6f, 0x64, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28,
+	0x0b, 0x32, 0x12, 0x2e, 0x68, 0x65, 0x61, 0x64, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x2e, 0x76, 0x31,
+	0x2e, 0x4e, 0x6f, 0x64, 0x65, 0x52, 0x04, 0x6e, 0x6f, 0x64, 0x65, 0x22, 0x2c, 0x0a, 0x11, 0x44,
+	0x65, 0x6c, 0x65, 0x74, 0x65, 0x4e, 0x6f, 0x64, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74,
+	0x12, 0x17, 0x0a, 0x07, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28,
+	0x04, 0x52, 0x06, 0x6e, 0x6f, 0x64, 0x65, 0x49, 0x64, 0x22, 0x14, 0x0a, 0x12, 0x44, 0x65, 0x6c,
+	0x65, 0x74, 0x65, 0x4e, 0x6f, 0x64, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22,
+	0x2c, 0x0a, 0x11, 0x45, 0x78, 0x70, 0x69, 0x72, 0x65, 0x4e, 0x6f, 0x64, 0x65, 0x52, 0x65, 0x71,
+	0x75, 0x65, 0x73, 0x74, 0x12, 0x17, 0x0a, 0x07, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x69, 0x64, 0x18,
+	0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x06, 0x6e, 0x6f, 0x64, 0x65, 0x49, 0x64, 0x22, 0x3c, 0x0a,
+	0x12, 0x45, 0x78, 0x70, 0x69, 0x72, 0x65, 0x4e, 0x6f, 0x64, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f,
+	0x6e, 0x73, 0x65, 0x12, 0x26, 0x0a, 0x04, 0x6e, 0x6f, 0x64, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28,
+	0x0b, 0x32, 0x12, 0x2e, 0x68, 0x65, 0x61, 0x64, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x2e, 0x76, 0x31,
+	0x2e, 0x4e, 0x6f, 0x64, 0x65, 0x52, 0x04, 0x6e, 0x6f, 0x64, 0x65, 0x22, 0x47, 0x0a, 0x11, 0x52,
+	0x65, 0x6e, 0x61, 0x6d, 0x65, 0x4e, 0x6f, 0x64, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74,
+	0x12, 0x17, 0x0a, 0x07, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28,
+	0x04, 0x52, 0x06, 0x6e, 0x6f, 0x64, 0x65, 0x49, 0x64, 0x12, 0x19, 0x0a, 0x08, 0x6e, 0x65, 0x77,
+	0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6e, 0x65, 0x77,
+	0x4e, 0x61, 0x6d, 0x65, 0x22, 0x3c, 0x0a, 0x12, 0x52, 0x65, 0x6e, 0x61, 0x6d, 0x65, 0x4e, 0x6f,
+	0x64, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x26, 0x0a, 0x04, 0x6e, 0x6f,
+	0x64, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x68, 0x65, 0x61, 0x64, 0x73,
+	0x63, 0x61, 0x6c, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x4e, 0x6f, 0x64, 0x65, 0x52, 0x04, 0x6e, 0x6f,
+	0x64, 0x65, 0x22, 0x26, 0x0a, 0x10, 0x4c, 0x69, 0x73, 0x74, 0x4e, 0x6f, 0x64, 0x65, 0x73, 0x52,
+	0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x75, 0x73, 0x65, 0x72, 0x18, 0x01,
+	0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x75, 0x73, 0x65, 0x72, 0x22, 0x3d, 0x0a, 0x11, 0x4c, 0x69,
+	0x73, 0x74, 0x4e, 0x6f, 0x64, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12,
+	0x28, 0x0a, 0x05, 0x6e, 0x6f, 0x64, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x12,
+	0x2e, 0x68, 0x65, 0x61, 0x64, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x4e, 0x6f,
+	0x64, 0x65, 0x52, 0x05, 0x6e, 0x6f, 0x64, 0x65, 0x73, 0x22, 0x3e, 0x0a, 0x0f, 0x4d, 0x6f, 0x76,
+	0x65, 0x4e, 0x6f, 0x64, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x17, 0x0a, 0x07,
+	0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x06, 0x6e,
+	0x6f, 0x64, 0x65, 0x49, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x75, 0x73, 0x65, 0x72, 0x18, 0x02, 0x20,
+	0x01, 0x28, 0x09, 0x52, 0x04, 0x75, 0x73, 0x65, 0x72, 0x22, 0x3a, 0x0a, 0x10, 0x4d, 0x6f, 0x76,
+	0x65, 0x4e, 0x6f, 0x64, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x26, 0x0a,
+	0x04, 0x6e, 0x6f, 0x64, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x68, 0x65,
+	0x61, 0x64, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x4e, 0x6f, 0x64, 0x65, 0x52,
+	0x04, 0x6e, 0x6f, 0x64, 0x65, 0x22, 0x6a, 0x0a, 0x16, 0x44, 0x65, 0x62, 0x75, 0x67, 0x43, 0x72,
+	0x65, 0x61, 0x74, 0x65, 0x4e, 0x6f, 0x64, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12,
+	0x12, 0x0a, 0x04, 0x75, 0x73, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x75,
+	0x73, 0x65, 0x72, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09,
+	0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x03, 0x20,
+	0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x72, 0x6f, 0x75,
+	0x74, 0x65, 0x73, 0x18, 0x04, 0x20, 0x03, 0x28, 0x09, 0x52, 0x06, 0x72, 0x6f, 0x75, 0x74, 0x65,
+	0x73, 0x22, 0x41, 0x0a, 0x17, 0x44, 0x65, 0x62, 0x75, 0x67, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65,
+	0x4e, 0x6f, 0x64, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x26, 0x0a, 0x04,
+	0x6e, 0x6f, 0x64, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x68, 0x65, 0x61,
+	0x64, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x4e, 0x6f, 0x64, 0x65, 0x52, 0x04,
+	0x6e, 0x6f, 0x64, 0x65, 0x2a, 0x82, 0x01, 0x0a, 0x0e, 0x52, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65,
+	0x72, 0x4d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x12, 0x1f, 0x0a, 0x1b, 0x52, 0x45, 0x47, 0x49, 0x53,
+	0x54, 0x45, 0x52, 0x5f, 0x4d, 0x45, 0x54, 0x48, 0x4f, 0x44, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45,
+	0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, 0x1c, 0x0a, 0x18, 0x52, 0x45, 0x47, 0x49,
+	0x53, 0x54, 0x45, 0x52, 0x5f, 0x4d, 0x45, 0x54, 0x48, 0x4f, 0x44, 0x5f, 0x41, 0x55, 0x54, 0x48,
+	0x5f, 0x4b, 0x45, 0x59, 0x10, 0x01, 0x12, 0x17, 0x0a, 0x13, 0x52, 0x45, 0x47, 0x49, 0x53, 0x54,
+	0x45, 0x52, 0x5f, 0x4d, 0x45, 0x54, 0x48, 0x4f, 0x44, 0x5f, 0x43, 0x4c, 0x49, 0x10, 0x02, 0x12,
+	0x18, 0x0a, 0x14, 0x52, 0x45, 0x47, 0x49, 0x53, 0x54, 0x45, 0x52, 0x5f, 0x4d, 0x45, 0x54, 0x48,
+	0x4f, 0x44, 0x5f, 0x4f, 0x49, 0x44, 0x43, 0x10, 0x03, 0x42, 0x29, 0x5a, 0x27, 0x67, 0x69, 0x74,
+	0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x6a, 0x75, 0x61, 0x6e, 0x66, 0x6f, 0x6e, 0x74,
+	0x2f, 0x68, 0x65, 0x61, 0x64, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x67,
+	0x6f, 0x2f, 0x76, 0x31, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
+}
+
+var (
+	file_headscale_v1_node_proto_rawDescOnce sync.Once
+	file_headscale_v1_node_proto_rawDescData = file_headscale_v1_node_proto_rawDesc
+)
+
+func file_headscale_v1_node_proto_rawDescGZIP() []byte {
+	file_headscale_v1_node_proto_rawDescOnce.Do(func() {
+		file_headscale_v1_node_proto_rawDescData = protoimpl.X.CompressGZIP(file_headscale_v1_node_proto_rawDescData)
+	})
+	return file_headscale_v1_node_proto_rawDescData
+}
+
+var file_headscale_v1_node_proto_enumTypes = make([]protoimpl.EnumInfo, 1)
+var file_headscale_v1_node_proto_msgTypes = make([]protoimpl.MessageInfo, 19)
+var file_headscale_v1_node_proto_goTypes = []interface{}{
+	(RegisterMethod)(0),             // 0: headscale.v1.RegisterMethod
+	(*Node)(nil),                    // 1: headscale.v1.Node
+	(*RegisterNodeRequest)(nil),     // 2: headscale.v1.RegisterNodeRequest
+	(*RegisterNodeResponse)(nil),    // 3: headscale.v1.RegisterNodeResponse
+	(*GetNodeRequest)(nil),          // 4: headscale.v1.GetNodeRequest
+	(*GetNodeResponse)(nil),         // 5: headscale.v1.GetNodeResponse
+	(*SetTagsRequest)(nil),          // 6: headscale.v1.SetTagsRequest
+	(*SetTagsResponse)(nil),         // 7: headscale.v1.SetTagsResponse
+	(*DeleteNodeRequest)(nil),       // 8: headscale.v1.DeleteNodeRequest
+	(*DeleteNodeResponse)(nil),      // 9: headscale.v1.DeleteNodeResponse
+	(*ExpireNodeRequest)(nil),       // 10: headscale.v1.ExpireNodeRequest
+	(*ExpireNodeResponse)(nil),      // 11: headscale.v1.ExpireNodeResponse
+	(*RenameNodeRequest)(nil),       // 12: headscale.v1.RenameNodeRequest
+	(*RenameNodeResponse)(nil),      // 13: headscale.v1.RenameNodeResponse
+	(*ListNodesRequest)(nil),        // 14: headscale.v1.ListNodesRequest
+	(*ListNodesResponse)(nil),       // 15: headscale.v1.ListNodesResponse
+	(*MoveNodeRequest)(nil),         // 16: headscale.v1.MoveNodeRequest
+	(*MoveNodeResponse)(nil),        // 17: headscale.v1.MoveNodeResponse
+	(*DebugCreateNodeRequest)(nil),  // 18: headscale.v1.DebugCreateNodeRequest
+	(*DebugCreateNodeResponse)(nil), // 19: headscale.v1.DebugCreateNodeResponse
+	(*User)(nil),                    // 20: headscale.v1.User
+	(*timestamppb.Timestamp)(nil),   // 21: google.protobuf.Timestamp
+	(*PreAuthKey)(nil),              // 22: headscale.v1.PreAuthKey
+}
+var file_headscale_v1_node_proto_depIdxs = []int32{
+	20, // 0: headscale.v1.Node.user:type_name -> headscale.v1.User
+	21, // 1: headscale.v1.Node.last_seen:type_name -> google.protobuf.Timestamp
+	21, // 2: headscale.v1.Node.last_successful_update:type_name -> google.protobuf.Timestamp
+	21, // 3: headscale.v1.Node.expiry:type_name -> google.protobuf.Timestamp
+	22, // 4: headscale.v1.Node.pre_auth_key:type_name -> headscale.v1.PreAuthKey
+	21, // 5: headscale.v1.Node.created_at:type_name -> google.protobuf.Timestamp
+	0,  // 6: headscale.v1.Node.register_method:type_name -> headscale.v1.RegisterMethod
+	1,  // 7: headscale.v1.RegisterNodeResponse.node:type_name -> headscale.v1.Node
+	1,  // 8: headscale.v1.GetNodeResponse.node:type_name -> headscale.v1.Node
+	1,  // 9: headscale.v1.SetTagsResponse.node:type_name -> headscale.v1.Node
+	1,  // 10: headscale.v1.ExpireNodeResponse.node:type_name -> headscale.v1.Node
+	1,  // 11: headscale.v1.RenameNodeResponse.node:type_name -> headscale.v1.Node
+	1,  // 12: headscale.v1.ListNodesResponse.nodes:type_name -> headscale.v1.Node
+	1,  // 13: headscale.v1.MoveNodeResponse.node:type_name -> headscale.v1.Node
+	1,  // 14: headscale.v1.DebugCreateNodeResponse.node:type_name -> headscale.v1.Node
+	15, // [15:15] is the sub-list for method output_type
+	15, // [15:15] is the sub-list for method input_type
+	15, // [15:15] is the sub-list for extension type_name
+	15, // [15:15] is the sub-list for extension extendee
+	0,  // [0:15] is the sub-list for field type_name
+}
+
+func init() { file_headscale_v1_node_proto_init() }
+func file_headscale_v1_node_proto_init() {
+	if File_headscale_v1_node_proto != nil {
+		return
+	}
+	file_headscale_v1_user_proto_init()
+	file_headscale_v1_preauthkey_proto_init()
+	if !protoimpl.UnsafeEnabled {
+		file_headscale_v1_node_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Node); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_headscale_v1_node_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*RegisterNodeRequest); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_headscale_v1_node_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*RegisterNodeResponse); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_headscale_v1_node_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*GetNodeRequest); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_headscale_v1_node_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*GetNodeResponse); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_headscale_v1_node_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*SetTagsRequest); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_headscale_v1_node_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*SetTagsResponse); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_headscale_v1_node_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*DeleteNodeRequest); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_headscale_v1_node_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*DeleteNodeResponse); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_headscale_v1_node_proto_msgTypes[9].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*ExpireNodeRequest); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_headscale_v1_node_proto_msgTypes[10].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*ExpireNodeResponse); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_headscale_v1_node_proto_msgTypes[11].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*RenameNodeRequest); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_headscale_v1_node_proto_msgTypes[12].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*RenameNodeResponse); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_headscale_v1_node_proto_msgTypes[13].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*ListNodesRequest); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_headscale_v1_node_proto_msgTypes[14].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*ListNodesResponse); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_headscale_v1_node_proto_msgTypes[15].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*MoveNodeRequest); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_headscale_v1_node_proto_msgTypes[16].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*MoveNodeResponse); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_headscale_v1_node_proto_msgTypes[17].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*DebugCreateNodeRequest); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_headscale_v1_node_proto_msgTypes[18].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*DebugCreateNodeResponse); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_headscale_v1_node_proto_rawDesc,
+			NumEnums:      1,
+			NumMessages:   19,
+			NumExtensions: 0,
+			NumServices:   0,
+		},
+		GoTypes:           file_headscale_v1_node_proto_goTypes,
+		DependencyIndexes: file_headscale_v1_node_proto_depIdxs,
+		EnumInfos:         file_headscale_v1_node_proto_enumTypes,
+		MessageInfos:      file_headscale_v1_node_proto_msgTypes,
+	}.Build()
+	File_headscale_v1_node_proto = out.File
+	file_headscale_v1_node_proto_rawDesc = nil
+	file_headscale_v1_node_proto_goTypes = nil
+	file_headscale_v1_node_proto_depIdxs = nil
+}
diff --git a/gen/go/headscale/v1/preauthkey.pb.go b/gen/go/headscale/v1/preauthkey.pb.go
index 0698b34b3d..856377f230 100644
--- a/gen/go/headscale/v1/preauthkey.pb.go
+++ b/gen/go/headscale/v1/preauthkey.pb.go
@@ -1,6 +1,6 @@
 // Code generated by protoc-gen-go. DO NOT EDIT.
 // versions:
-// 	protoc-gen-go v1.29.1
+// 	protoc-gen-go v1.31.0
 // 	protoc        (unknown)
 // source: headscale/v1/preauthkey.proto
 
diff --git a/gen/go/headscale/v1/routes.pb.go b/gen/go/headscale/v1/routes.pb.go
index 154f78bb46..051e92e906 100644
--- a/gen/go/headscale/v1/routes.pb.go
+++ b/gen/go/headscale/v1/routes.pb.go
@@ -1,6 +1,6 @@
 // Code generated by protoc-gen-go. DO NOT EDIT.
 // versions:
-// 	protoc-gen-go v1.29.1
+// 	protoc-gen-go v1.31.0
 // 	protoc        (unknown)
 // source: headscale/v1/routes.proto
 
@@ -27,7 +27,7 @@ type Route struct {
 	unknownFields protoimpl.UnknownFields
 
 	Id         uint64                 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
-	Machine    *Machine               `protobuf:"bytes,2,opt,name=machine,proto3" json:"machine,omitempty"`
+	Node       *Node                  `protobuf:"bytes,2,opt,name=node,proto3" json:"node,omitempty"`
 	Prefix     string                 `protobuf:"bytes,3,opt,name=prefix,proto3" json:"prefix,omitempty"`
 	Advertised bool                   `protobuf:"varint,4,opt,name=advertised,proto3" json:"advertised,omitempty"`
 	Enabled    bool                   `protobuf:"varint,5,opt,name=enabled,proto3" json:"enabled,omitempty"`
@@ -76,9 +76,9 @@ func (x *Route) GetId() uint64 {
 	return 0
 }
 
-func (x *Route) GetMachine() *Machine {
+func (x *Route) GetNode() *Node {
 	if x != nil {
-		return x.Machine
+		return x.Node
 	}
 	return nil
 }
@@ -387,16 +387,16 @@ func (*DisableRouteResponse) Descriptor() ([]byte, []int) {
 	return file_headscale_v1_routes_proto_rawDescGZIP(), []int{6}
 }
 
-type GetMachineRoutesRequest struct {
+type GetNodeRoutesRequest struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	MachineId uint64 `protobuf:"varint,1,opt,name=machine_id,json=machineId,proto3" json:"machine_id,omitempty"`
+	NodeId uint64 `protobuf:"varint,1,opt,name=node_id,json=nodeId,proto3" json:"node_id,omitempty"`
 }
 
-func (x *GetMachineRoutesRequest) Reset() {
-	*x = GetMachineRoutesRequest{}
+func (x *GetNodeRoutesRequest) Reset() {
+	*x = GetNodeRoutesRequest{}
 	if protoimpl.UnsafeEnabled {
 		mi := &file_headscale_v1_routes_proto_msgTypes[7]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -404,13 +404,13 @@ func (x *GetMachineRoutesRequest) Reset() {
 	}
 }
 
-func (x *GetMachineRoutesRequest) String() string {
+func (x *GetNodeRoutesRequest) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*GetMachineRoutesRequest) ProtoMessage() {}
+func (*GetNodeRoutesRequest) ProtoMessage() {}
 
-func (x *GetMachineRoutesRequest) ProtoReflect() protoreflect.Message {
+func (x *GetNodeRoutesRequest) ProtoReflect() protoreflect.Message {
 	mi := &file_headscale_v1_routes_proto_msgTypes[7]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -422,19 +422,19 @@ func (x *GetMachineRoutesRequest) ProtoReflect() protoreflect.Message {
 	return mi.MessageOf(x)
 }
 
-// Deprecated: Use GetMachineRoutesRequest.ProtoReflect.Descriptor instead.
-func (*GetMachineRoutesRequest) Descriptor() ([]byte, []int) {
+// Deprecated: Use GetNodeRoutesRequest.ProtoReflect.Descriptor instead.
+func (*GetNodeRoutesRequest) Descriptor() ([]byte, []int) {
 	return file_headscale_v1_routes_proto_rawDescGZIP(), []int{7}
 }
 
-func (x *GetMachineRoutesRequest) GetMachineId() uint64 {
+func (x *GetNodeRoutesRequest) GetNodeId() uint64 {
 	if x != nil {
-		return x.MachineId
+		return x.NodeId
 	}
 	return 0
 }
 
-type GetMachineRoutesResponse struct {
+type GetNodeRoutesResponse struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
@@ -442,8 +442,8 @@ type GetMachineRoutesResponse struct {
 	Routes []*Route `protobuf:"bytes,1,rep,name=routes,proto3" json:"routes,omitempty"`
 }
 
-func (x *GetMachineRoutesResponse) Reset() {
-	*x = GetMachineRoutesResponse{}
+func (x *GetNodeRoutesResponse) Reset() {
+	*x = GetNodeRoutesResponse{}
 	if protoimpl.UnsafeEnabled {
 		mi := &file_headscale_v1_routes_proto_msgTypes[8]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -451,13 +451,13 @@ func (x *GetMachineRoutesResponse) Reset() {
 	}
 }
 
-func (x *GetMachineRoutesResponse) String() string {
+func (x *GetNodeRoutesResponse) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*GetMachineRoutesResponse) ProtoMessage() {}
+func (*GetNodeRoutesResponse) ProtoMessage() {}
 
-func (x *GetMachineRoutesResponse) ProtoReflect() protoreflect.Message {
+func (x *GetNodeRoutesResponse) ProtoReflect() protoreflect.Message {
 	mi := &file_headscale_v1_routes_proto_msgTypes[8]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -469,12 +469,12 @@ func (x *GetMachineRoutesResponse) ProtoReflect() protoreflect.Message {
 	return mi.MessageOf(x)
 }
 
-// Deprecated: Use GetMachineRoutesResponse.ProtoReflect.Descriptor instead.
-func (*GetMachineRoutesResponse) Descriptor() ([]byte, []int) {
+// Deprecated: Use GetNodeRoutesResponse.ProtoReflect.Descriptor instead.
+func (*GetNodeRoutesResponse) Descriptor() ([]byte, []int) {
 	return file_headscale_v1_routes_proto_rawDescGZIP(), []int{8}
 }
 
-func (x *GetMachineRoutesResponse) GetRoutes() []*Route {
+func (x *GetNodeRoutesResponse) GetRoutes() []*Route {
 	if x != nil {
 		return x.Routes
 	}
@@ -573,62 +573,61 @@ var file_headscale_v1_routes_proto_rawDesc = []byte{
 	0x6f, 0x75, 0x74, 0x65, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x0c, 0x68, 0x65, 0x61,
 	0x64, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x2e, 0x76, 0x31, 0x1a, 0x1f, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
 	0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x69, 0x6d, 0x65, 0x73,
-	0x74, 0x61, 0x6d, 0x70, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1a, 0x68, 0x65, 0x61, 0x64,
-	0x73, 0x63, 0x61, 0x6c, 0x65, 0x2f, 0x76, 0x31, 0x2f, 0x6d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65,
-	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xea, 0x02, 0x0a, 0x05, 0x52, 0x6f, 0x75, 0x74, 0x65,
-	0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x02, 0x69, 0x64,
-	0x12, 0x2f, 0x0a, 0x07, 0x6d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28,
-	0x0b, 0x32, 0x15, 0x2e, 0x68, 0x65, 0x61, 0x64, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x2e, 0x76, 0x31,
-	0x2e, 0x4d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x52, 0x07, 0x6d, 0x61, 0x63, 0x68, 0x69, 0x6e,
-	0x65, 0x12, 0x16, 0x0a, 0x06, 0x70, 0x72, 0x65, 0x66, 0x69, 0x78, 0x18, 0x03, 0x20, 0x01, 0x28,
-	0x09, 0x52, 0x06, 0x70, 0x72, 0x65, 0x66, 0x69, 0x78, 0x12, 0x1e, 0x0a, 0x0a, 0x61, 0x64, 0x76,
-	0x65, 0x72, 0x74, 0x69, 0x73, 0x65, 0x64, 0x18, 0x04, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, 0x61,
-	0x64, 0x76, 0x65, 0x72, 0x74, 0x69, 0x73, 0x65, 0x64, 0x12, 0x18, 0x0a, 0x07, 0x65, 0x6e, 0x61,
-	0x62, 0x6c, 0x65, 0x64, 0x18, 0x05, 0x20, 0x01, 0x28, 0x08, 0x52, 0x07, 0x65, 0x6e, 0x61, 0x62,
-	0x6c, 0x65, 0x64, 0x12, 0x1d, 0x0a, 0x0a, 0x69, 0x73, 0x5f, 0x70, 0x72, 0x69, 0x6d, 0x61, 0x72,
-	0x79, 0x18, 0x06, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x69, 0x73, 0x50, 0x72, 0x69, 0x6d, 0x61,
-	0x72, 0x79, 0x12, 0x39, 0x0a, 0x0a, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x61, 0x74,
-	0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e,
-	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61,
-	0x6d, 0x70, 0x52, 0x09, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x41, 0x74, 0x12, 0x39, 0x0a,
-	0x0a, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x61, 0x74, 0x18, 0x08, 0x20, 0x01, 0x28,
-	0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
-	0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x09, 0x75,
-	0x70, 0x64, 0x61, 0x74, 0x65, 0x64, 0x41, 0x74, 0x12, 0x39, 0x0a, 0x0a, 0x64, 0x65, 0x6c, 0x65,
-	0x74, 0x65, 0x64, 0x5f, 0x61, 0x74, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67,
-	0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54,
-	0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x09, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65,
-	0x64, 0x41, 0x74, 0x22, 0x12, 0x0a, 0x10, 0x47, 0x65, 0x74, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x73,
-	0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0x40, 0x0a, 0x11, 0x47, 0x65, 0x74, 0x52, 0x6f,
-	0x75, 0x74, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x2b, 0x0a, 0x06,
-	0x72, 0x6f, 0x75, 0x74, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x13, 0x2e, 0x68,
-	0x65, 0x61, 0x64, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x6f, 0x75, 0x74,
-	0x65, 0x52, 0x06, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x73, 0x22, 0x2f, 0x0a, 0x12, 0x45, 0x6e, 0x61,
-	0x62, 0x6c, 0x65, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12,
-	0x19, 0x0a, 0x08, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28,
-	0x04, 0x52, 0x07, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x49, 0x64, 0x22, 0x15, 0x0a, 0x13, 0x45, 0x6e,
-	0x61, 0x62, 0x6c, 0x65, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73,
-	0x65, 0x22, 0x30, 0x0a, 0x13, 0x44, 0x69, 0x73, 0x61, 0x62, 0x6c, 0x65, 0x52, 0x6f, 0x75, 0x74,
-	0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x19, 0x0a, 0x08, 0x72, 0x6f, 0x75, 0x74,
-	0x65, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x07, 0x72, 0x6f, 0x75, 0x74,
-	0x65, 0x49, 0x64, 0x22, 0x16, 0x0a, 0x14, 0x44, 0x69, 0x73, 0x61, 0x62, 0x6c, 0x65, 0x52, 0x6f,
-	0x75, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x38, 0x0a, 0x17, 0x47,
-	0x65, 0x74, 0x4d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x73, 0x52,
-	0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1d, 0x0a, 0x0a, 0x6d, 0x61, 0x63, 0x68, 0x69, 0x6e,
-	0x65, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x09, 0x6d, 0x61, 0x63, 0x68,
-	0x69, 0x6e, 0x65, 0x49, 0x64, 0x22, 0x47, 0x0a, 0x18, 0x47, 0x65, 0x74, 0x4d, 0x61, 0x63, 0x68,
-	0x69, 0x6e, 0x65, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73,
-	0x65, 0x12, 0x2b, 0x0a, 0x06, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28,
-	0x0b, 0x32, 0x13, 0x2e, 0x68, 0x65, 0x61, 0x64, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x2e, 0x76, 0x31,
-	0x2e, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x52, 0x06, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x73, 0x22, 0x2f,
-	0x0a, 0x12, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x52, 0x65, 0x71,
-	0x75, 0x65, 0x73, 0x74, 0x12, 0x19, 0x0a, 0x08, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x5f, 0x69, 0x64,
-	0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x07, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x49, 0x64, 0x22,
-	0x15, 0x0a, 0x13, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x52, 0x65,
-	0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x42, 0x29, 0x5a, 0x27, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62,
-	0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x6a, 0x75, 0x61, 0x6e, 0x66, 0x6f, 0x6e, 0x74, 0x2f, 0x68, 0x65,
-	0x61, 0x64, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x67, 0x6f, 0x2f, 0x76,
-	0x31, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
+	0x74, 0x61, 0x6d, 0x70, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x17, 0x68, 0x65, 0x61, 0x64,
+	0x73, 0x63, 0x61, 0x6c, 0x65, 0x2f, 0x76, 0x31, 0x2f, 0x6e, 0x6f, 0x64, 0x65, 0x2e, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x22, 0xe1, 0x02, 0x0a, 0x05, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x12, 0x0e, 0x0a,
+	0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x02, 0x69, 0x64, 0x12, 0x26, 0x0a,
+	0x04, 0x6e, 0x6f, 0x64, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x68, 0x65,
+	0x61, 0x64, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x4e, 0x6f, 0x64, 0x65, 0x52,
+	0x04, 0x6e, 0x6f, 0x64, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x70, 0x72, 0x65, 0x66, 0x69, 0x78, 0x18,
+	0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x70, 0x72, 0x65, 0x66, 0x69, 0x78, 0x12, 0x1e, 0x0a,
+	0x0a, 0x61, 0x64, 0x76, 0x65, 0x72, 0x74, 0x69, 0x73, 0x65, 0x64, 0x18, 0x04, 0x20, 0x01, 0x28,
+	0x08, 0x52, 0x0a, 0x61, 0x64, 0x76, 0x65, 0x72, 0x74, 0x69, 0x73, 0x65, 0x64, 0x12, 0x18, 0x0a,
+	0x07, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x18, 0x05, 0x20, 0x01, 0x28, 0x08, 0x52, 0x07,
+	0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x12, 0x1d, 0x0a, 0x0a, 0x69, 0x73, 0x5f, 0x70, 0x72,
+	0x69, 0x6d, 0x61, 0x72, 0x79, 0x18, 0x06, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x69, 0x73, 0x50,
+	0x72, 0x69, 0x6d, 0x61, 0x72, 0x79, 0x12, 0x39, 0x0a, 0x0a, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65,
+	0x64, 0x5f, 0x61, 0x74, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d,
+	0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x09, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x41,
+	0x74, 0x12, 0x39, 0x0a, 0x0a, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x61, 0x74, 0x18,
+	0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d,
+	0x70, 0x52, 0x09, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x64, 0x41, 0x74, 0x12, 0x39, 0x0a, 0x0a,
+	0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x64, 0x5f, 0x61, 0x74, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0b,
+	0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62,
+	0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x09, 0x64, 0x65,
+	0x6c, 0x65, 0x74, 0x65, 0x64, 0x41, 0x74, 0x22, 0x12, 0x0a, 0x10, 0x47, 0x65, 0x74, 0x52, 0x6f,
+	0x75, 0x74, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0x40, 0x0a, 0x11, 0x47,
+	0x65, 0x74, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
+	0x12, 0x2b, 0x0a, 0x06, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b,
+	0x32, 0x13, 0x2e, 0x68, 0x65, 0x61, 0x64, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x2e, 0x76, 0x31, 0x2e,
+	0x52, 0x6f, 0x75, 0x74, 0x65, 0x52, 0x06, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x73, 0x22, 0x2f, 0x0a,
+	0x12, 0x45, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75,
+	0x65, 0x73, 0x74, 0x12, 0x19, 0x0a, 0x08, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x5f, 0x69, 0x64, 0x18,
+	0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x07, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x49, 0x64, 0x22, 0x15,
+	0x0a, 0x13, 0x45, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x52, 0x65, 0x73,
+	0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x30, 0x0a, 0x13, 0x44, 0x69, 0x73, 0x61, 0x62, 0x6c, 0x65,
+	0x52, 0x6f, 0x75, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x19, 0x0a, 0x08,
+	0x72, 0x6f, 0x75, 0x74, 0x65, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x07,
+	0x72, 0x6f, 0x75, 0x74, 0x65, 0x49, 0x64, 0x22, 0x16, 0x0a, 0x14, 0x44, 0x69, 0x73, 0x61, 0x62,
+	0x6c, 0x65, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22,
+	0x2f, 0x0a, 0x14, 0x47, 0x65, 0x74, 0x4e, 0x6f, 0x64, 0x65, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x73,
+	0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x17, 0x0a, 0x07, 0x6e, 0x6f, 0x64, 0x65, 0x5f,
+	0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x06, 0x6e, 0x6f, 0x64, 0x65, 0x49, 0x64,
+	0x22, 0x44, 0x0a, 0x15, 0x47, 0x65, 0x74, 0x4e, 0x6f, 0x64, 0x65, 0x52, 0x6f, 0x75, 0x74, 0x65,
+	0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x2b, 0x0a, 0x06, 0x72, 0x6f, 0x75,
+	0x74, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x13, 0x2e, 0x68, 0x65, 0x61, 0x64,
+	0x73, 0x63, 0x61, 0x6c, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x52, 0x06,
+	0x72, 0x6f, 0x75, 0x74, 0x65, 0x73, 0x22, 0x2f, 0x0a, 0x12, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65,
+	0x52, 0x6f, 0x75, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x19, 0x0a, 0x08,
+	0x72, 0x6f, 0x75, 0x74, 0x65, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x07,
+	0x72, 0x6f, 0x75, 0x74, 0x65, 0x49, 0x64, 0x22, 0x15, 0x0a, 0x13, 0x44, 0x65, 0x6c, 0x65, 0x74,
+	0x65, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x42, 0x29,
+	0x5a, 0x27, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x6a, 0x75, 0x61,
+	0x6e, 0x66, 0x6f, 0x6e, 0x74, 0x2f, 0x68, 0x65, 0x61, 0x64, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x2f,
+	0x67, 0x65, 0x6e, 0x2f, 0x67, 0x6f, 0x2f, 0x76, 0x31, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x33,
 }
 
 var (
@@ -645,27 +644,27 @@ func file_headscale_v1_routes_proto_rawDescGZIP() []byte {
 
 var file_headscale_v1_routes_proto_msgTypes = make([]protoimpl.MessageInfo, 11)
 var file_headscale_v1_routes_proto_goTypes = []interface{}{
-	(*Route)(nil),                    // 0: headscale.v1.Route
-	(*GetRoutesRequest)(nil),         // 1: headscale.v1.GetRoutesRequest
-	(*GetRoutesResponse)(nil),        // 2: headscale.v1.GetRoutesResponse
-	(*EnableRouteRequest)(nil),       // 3: headscale.v1.EnableRouteRequest
-	(*EnableRouteResponse)(nil),      // 4: headscale.v1.EnableRouteResponse
-	(*DisableRouteRequest)(nil),      // 5: headscale.v1.DisableRouteRequest
-	(*DisableRouteResponse)(nil),     // 6: headscale.v1.DisableRouteResponse
-	(*GetMachineRoutesRequest)(nil),  // 7: headscale.v1.GetMachineRoutesRequest
-	(*GetMachineRoutesResponse)(nil), // 8: headscale.v1.GetMachineRoutesResponse
-	(*DeleteRouteRequest)(nil),       // 9: headscale.v1.DeleteRouteRequest
-	(*DeleteRouteResponse)(nil),      // 10: headscale.v1.DeleteRouteResponse
-	(*Machine)(nil),                  // 11: headscale.v1.Machine
-	(*timestamppb.Timestamp)(nil),    // 12: google.protobuf.Timestamp
+	(*Route)(nil),                 // 0: headscale.v1.Route
+	(*GetRoutesRequest)(nil),      // 1: headscale.v1.GetRoutesRequest
+	(*GetRoutesResponse)(nil),     // 2: headscale.v1.GetRoutesResponse
+	(*EnableRouteRequest)(nil),    // 3: headscale.v1.EnableRouteRequest
+	(*EnableRouteResponse)(nil),   // 4: headscale.v1.EnableRouteResponse
+	(*DisableRouteRequest)(nil),   // 5: headscale.v1.DisableRouteRequest
+	(*DisableRouteResponse)(nil),  // 6: headscale.v1.DisableRouteResponse
+	(*GetNodeRoutesRequest)(nil),  // 7: headscale.v1.GetNodeRoutesRequest
+	(*GetNodeRoutesResponse)(nil), // 8: headscale.v1.GetNodeRoutesResponse
+	(*DeleteRouteRequest)(nil),    // 9: headscale.v1.DeleteRouteRequest
+	(*DeleteRouteResponse)(nil),   // 10: headscale.v1.DeleteRouteResponse
+	(*Node)(nil),                  // 11: headscale.v1.Node
+	(*timestamppb.Timestamp)(nil), // 12: google.protobuf.Timestamp
 }
 var file_headscale_v1_routes_proto_depIdxs = []int32{
-	11, // 0: headscale.v1.Route.machine:type_name -> headscale.v1.Machine
+	11, // 0: headscale.v1.Route.node:type_name -> headscale.v1.Node
 	12, // 1: headscale.v1.Route.created_at:type_name -> google.protobuf.Timestamp
 	12, // 2: headscale.v1.Route.updated_at:type_name -> google.protobuf.Timestamp
 	12, // 3: headscale.v1.Route.deleted_at:type_name -> google.protobuf.Timestamp
 	0,  // 4: headscale.v1.GetRoutesResponse.routes:type_name -> headscale.v1.Route
-	0,  // 5: headscale.v1.GetMachineRoutesResponse.routes:type_name -> headscale.v1.Route
+	0,  // 5: headscale.v1.GetNodeRoutesResponse.routes:type_name -> headscale.v1.Route
 	6,  // [6:6] is the sub-list for method output_type
 	6,  // [6:6] is the sub-list for method input_type
 	6,  // [6:6] is the sub-list for extension type_name
@@ -678,7 +677,7 @@ func file_headscale_v1_routes_proto_init() {
 	if File_headscale_v1_routes_proto != nil {
 		return
 	}
-	file_headscale_v1_machine_proto_init()
+	file_headscale_v1_node_proto_init()
 	if !protoimpl.UnsafeEnabled {
 		file_headscale_v1_routes_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
 			switch v := v.(*Route); i {
@@ -765,7 +764,7 @@ func file_headscale_v1_routes_proto_init() {
 			}
 		}
 		file_headscale_v1_routes_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*GetMachineRoutesRequest); i {
+			switch v := v.(*GetNodeRoutesRequest); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -777,7 +776,7 @@ func file_headscale_v1_routes_proto_init() {
 			}
 		}
 		file_headscale_v1_routes_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*GetMachineRoutesResponse); i {
+			switch v := v.(*GetNodeRoutesResponse); i {
 			case 0:
 				return &v.state
 			case 1:
diff --git a/gen/go/headscale/v1/user.pb.go b/gen/go/headscale/v1/user.pb.go
index 46c3740dad..3fbe969d8c 100644
--- a/gen/go/headscale/v1/user.pb.go
+++ b/gen/go/headscale/v1/user.pb.go
@@ -1,6 +1,6 @@
 // Code generated by protoc-gen-go. DO NOT EDIT.
 // versions:
-// 	protoc-gen-go v1.29.1
+// 	protoc-gen-go v1.31.0
 // 	protoc        (unknown)
 // source: headscale/v1/user.proto
 
diff --git a/gen/openapiv2/headscale/v1/headscale.swagger.json b/gen/openapiv2/headscale/v1/headscale.swagger.json
index 83103c16a6..bf48b14346 100644
--- a/gen/openapiv2/headscale/v1/headscale.swagger.json
+++ b/gen/openapiv2/headscale/v1/headscale.swagger.json
@@ -101,15 +101,15 @@
         ]
       }
     },
-    "/api/v1/debug/machine": {
+    "/api/v1/debug/node": {
       "post": {
-        "summary": "--- Machine start ---",
-        "operationId": "HeadscaleService_DebugCreateMachine",
+        "summary": "--- Node start ---",
+        "operationId": "HeadscaleService_DebugCreateNode",
         "responses": {
           "200": {
             "description": "A successful response.",
             "schema": {
-              "$ref": "#/definitions/v1DebugCreateMachineResponse"
+              "$ref": "#/definitions/v1DebugCreateNodeResponse"
             }
           },
           "default": {
@@ -125,7 +125,7 @@
             "in": "body",
             "required": true,
             "schema": {
-              "$ref": "#/definitions/v1DebugCreateMachineRequest"
+              "$ref": "#/definitions/v1DebugCreateNodeRequest"
             }
           }
         ],
@@ -134,14 +134,14 @@
         ]
       }
     },
-    "/api/v1/machine": {
+    "/api/v1/node": {
       "get": {
-        "operationId": "HeadscaleService_ListMachines",
+        "operationId": "HeadscaleService_ListNodes",
         "responses": {
           "200": {
             "description": "A successful response.",
             "schema": {
-              "$ref": "#/definitions/v1ListMachinesResponse"
+              "$ref": "#/definitions/v1ListNodesResponse"
             }
           },
           "default": {
@@ -164,14 +164,14 @@
         ]
       }
     },
-    "/api/v1/machine/register": {
+    "/api/v1/node/register": {
       "post": {
-        "operationId": "HeadscaleService_RegisterMachine",
+        "operationId": "HeadscaleService_RegisterNode",
         "responses": {
           "200": {
             "description": "A successful response.",
             "schema": {
-              "$ref": "#/definitions/v1RegisterMachineResponse"
+              "$ref": "#/definitions/v1RegisterNodeResponse"
             }
           },
           "default": {
@@ -200,14 +200,14 @@
         ]
       }
     },
-    "/api/v1/machine/{machineId}": {
+    "/api/v1/node/{nodeId}": {
       "get": {
-        "operationId": "HeadscaleService_GetMachine",
+        "operationId": "HeadscaleService_GetNode",
         "responses": {
           "200": {
             "description": "A successful response.",
             "schema": {
-              "$ref": "#/definitions/v1GetMachineResponse"
+              "$ref": "#/definitions/v1GetNodeResponse"
             }
           },
           "default": {
@@ -219,7 +219,7 @@
         },
         "parameters": [
           {
-            "name": "machineId",
+            "name": "nodeId",
             "in": "path",
             "required": true,
             "type": "string",
@@ -231,12 +231,12 @@
         ]
       },
       "delete": {
-        "operationId": "HeadscaleService_DeleteMachine",
+        "operationId": "HeadscaleService_DeleteNode",
         "responses": {
           "200": {
             "description": "A successful response.",
             "schema": {
-              "$ref": "#/definitions/v1DeleteMachineResponse"
+              "$ref": "#/definitions/v1DeleteNodeResponse"
             }
           },
           "default": {
@@ -248,7 +248,7 @@
         },
         "parameters": [
           {
-            "name": "machineId",
+            "name": "nodeId",
             "in": "path",
             "required": true,
             "type": "string",
@@ -260,14 +260,14 @@
         ]
       }
     },
-    "/api/v1/machine/{machineId}/expire": {
+    "/api/v1/node/{nodeId}/expire": {
       "post": {
-        "operationId": "HeadscaleService_ExpireMachine",
+        "operationId": "HeadscaleService_ExpireNode",
         "responses": {
           "200": {
             "description": "A successful response.",
             "schema": {
-              "$ref": "#/definitions/v1ExpireMachineResponse"
+              "$ref": "#/definitions/v1ExpireNodeResponse"
             }
           },
           "default": {
@@ -279,7 +279,7 @@
         },
         "parameters": [
           {
-            "name": "machineId",
+            "name": "nodeId",
             "in": "path",
             "required": true,
             "type": "string",
@@ -291,14 +291,14 @@
         ]
       }
     },
-    "/api/v1/machine/{machineId}/rename/{newName}": {
+    "/api/v1/node/{nodeId}/rename/{newName}": {
       "post": {
-        "operationId": "HeadscaleService_RenameMachine",
+        "operationId": "HeadscaleService_RenameNode",
         "responses": {
           "200": {
             "description": "A successful response.",
             "schema": {
-              "$ref": "#/definitions/v1RenameMachineResponse"
+              "$ref": "#/definitions/v1RenameNodeResponse"
             }
           },
           "default": {
@@ -310,7 +310,7 @@
         },
         "parameters": [
           {
-            "name": "machineId",
+            "name": "nodeId",
             "in": "path",
             "required": true,
             "type": "string",
@@ -328,14 +328,14 @@
         ]
       }
     },
-    "/api/v1/machine/{machineId}/routes": {
+    "/api/v1/node/{nodeId}/routes": {
       "get": {
-        "operationId": "HeadscaleService_GetMachineRoutes",
+        "operationId": "HeadscaleService_GetNodeRoutes",
         "responses": {
           "200": {
             "description": "A successful response.",
             "schema": {
-              "$ref": "#/definitions/v1GetMachineRoutesResponse"
+              "$ref": "#/definitions/v1GetNodeRoutesResponse"
             }
           },
           "default": {
@@ -347,7 +347,7 @@
         },
         "parameters": [
           {
-            "name": "machineId",
+            "name": "nodeId",
             "in": "path",
             "required": true,
             "type": "string",
@@ -359,7 +359,7 @@
         ]
       }
     },
-    "/api/v1/machine/{machineId}/tags": {
+    "/api/v1/node/{nodeId}/tags": {
       "post": {
         "operationId": "HeadscaleService_SetTags",
         "responses": {
@@ -378,7 +378,7 @@
         },
         "parameters": [
           {
-            "name": "machineId",
+            "name": "nodeId",
             "in": "path",
             "required": true,
             "type": "string",
@@ -406,14 +406,14 @@
         ]
       }
     },
-    "/api/v1/machine/{machineId}/user": {
+    "/api/v1/node/{nodeId}/user": {
       "post": {
-        "operationId": "HeadscaleService_MoveMachine",
+        "operationId": "HeadscaleService_MoveNode",
         "responses": {
           "200": {
             "description": "A successful response.",
             "schema": {
-              "$ref": "#/definitions/v1MoveMachineResponse"
+              "$ref": "#/definitions/v1MoveNodeResponse"
             }
           },
           "default": {
@@ -425,7 +425,7 @@
         },
         "parameters": [
           {
-            "name": "machineId",
+            "name": "nodeId",
             "in": "path",
             "required": true,
             "type": "string",
@@ -917,7 +917,7 @@
         }
       }
     },
-    "v1DebugCreateMachineRequest": {
+    "v1DebugCreateNodeRequest": {
       "type": "object",
       "properties": {
         "user": {
@@ -937,15 +937,15 @@
         }
       }
     },
-    "v1DebugCreateMachineResponse": {
+    "v1DebugCreateNodeResponse": {
       "type": "object",
       "properties": {
-        "machine": {
-          "$ref": "#/definitions/v1Machine"
+        "node": {
+          "$ref": "#/definitions/v1Node"
         }
       }
     },
-    "v1DeleteMachineResponse": {
+    "v1DeleteNodeResponse": {
       "type": "object"
     },
     "v1DeleteRouteResponse": {
@@ -971,11 +971,11 @@
     "v1ExpireApiKeyResponse": {
       "type": "object"
     },
-    "v1ExpireMachineResponse": {
+    "v1ExpireNodeResponse": {
       "type": "object",
       "properties": {
-        "machine": {
-          "$ref": "#/definitions/v1Machine"
+        "node": {
+          "$ref": "#/definitions/v1Node"
         }
       }
     },
@@ -993,15 +993,15 @@
     "v1ExpirePreAuthKeyResponse": {
       "type": "object"
     },
-    "v1GetMachineResponse": {
+    "v1GetNodeResponse": {
       "type": "object",
       "properties": {
-        "machine": {
-          "$ref": "#/definitions/v1Machine"
+        "node": {
+          "$ref": "#/definitions/v1Node"
         }
       }
     },
-    "v1GetMachineRoutesResponse": {
+    "v1GetNodeRoutesResponse": {
       "type": "object",
       "properties": {
         "routes": {
@@ -1042,13 +1042,13 @@
         }
       }
     },
-    "v1ListMachinesResponse": {
+    "v1ListNodesResponse": {
       "type": "object",
       "properties": {
-        "machines": {
+        "nodes": {
           "type": "array",
           "items": {
-            "$ref": "#/definitions/v1Machine"
+            "$ref": "#/definitions/v1Node"
           }
         }
       }
@@ -1075,7 +1075,15 @@
         }
       }
     },
-    "v1Machine": {
+    "v1MoveNodeResponse": {
+      "type": "object",
+      "properties": {
+        "node": {
+          "$ref": "#/definitions/v1Node"
+        }
+      }
+    },
+    "v1Node": {
       "type": "object",
       "properties": {
         "id": {
@@ -1151,14 +1159,6 @@
         }
       }
     },
-    "v1MoveMachineResponse": {
-      "type": "object",
-      "properties": {
-        "machine": {
-          "$ref": "#/definitions/v1Machine"
-        }
-      }
-    },
     "v1PreAuthKey": {
       "type": "object",
       "properties": {
@@ -1196,14 +1196,6 @@
         }
       }
     },
-    "v1RegisterMachineResponse": {
-      "type": "object",
-      "properties": {
-        "machine": {
-          "$ref": "#/definitions/v1Machine"
-        }
-      }
-    },
     "v1RegisterMethod": {
       "type": "string",
       "enum": [
@@ -1214,11 +1206,19 @@
       ],
       "default": "REGISTER_METHOD_UNSPECIFIED"
     },
-    "v1RenameMachineResponse": {
+    "v1RegisterNodeResponse": {
+      "type": "object",
+      "properties": {
+        "node": {
+          "$ref": "#/definitions/v1Node"
+        }
+      }
+    },
+    "v1RenameNodeResponse": {
       "type": "object",
       "properties": {
-        "machine": {
-          "$ref": "#/definitions/v1Machine"
+        "node": {
+          "$ref": "#/definitions/v1Node"
         }
       }
     },
@@ -1237,8 +1237,8 @@
           "type": "string",
           "format": "uint64"
         },
-        "machine": {
-          "$ref": "#/definitions/v1Machine"
+        "node": {
+          "$ref": "#/definitions/v1Node"
         },
         "prefix": {
           "type": "string"
@@ -1269,8 +1269,8 @@
     "v1SetTagsResponse": {
       "type": "object",
       "properties": {
-        "machine": {
-          "$ref": "#/definitions/v1Machine"
+        "node": {
+          "$ref": "#/definitions/v1Node"
         }
       }
     },
diff --git a/gen/openapiv2/headscale/v1/machine.swagger.json b/gen/openapiv2/headscale/v1/node.swagger.json
similarity index 94%
rename from gen/openapiv2/headscale/v1/machine.swagger.json
rename to gen/openapiv2/headscale/v1/node.swagger.json
index 714624b87c..8271250ebd 100644
--- a/gen/openapiv2/headscale/v1/machine.swagger.json
+++ b/gen/openapiv2/headscale/v1/node.swagger.json
@@ -1,7 +1,7 @@
 {
   "swagger": "2.0",
   "info": {
-    "title": "headscale/v1/machine.proto",
+    "title": "headscale/v1/node.proto",
     "version": "version not set"
   },
   "consumes": [
diff --git a/hscontrol/app.go b/hscontrol/app.go
index 630339c136..59284cb140 100644
--- a/hscontrol/app.go
+++ b/hscontrol/app.go
@@ -220,16 +220,16 @@ func (h *Headscale) redirect(w http.ResponseWriter, req *http.Request) {
 	http.Redirect(w, req, target, http.StatusFound)
 }
 
-// expireEphemeralNodes deletes ephemeral machine records that have not been
+// expireEphemeralNodes deletes ephemeral node records that have not been
 // seen for longer than h.cfg.EphemeralNodeInactivityTimeout.
 func (h *Headscale) expireEphemeralNodes(milliSeconds int64) {
 	ticker := time.NewTicker(time.Duration(milliSeconds) * time.Millisecond)
 	for range ticker.C {
-		h.db.ExpireEphemeralMachines(h.cfg.EphemeralNodeInactivityTimeout)
+		h.db.ExpireEphemeralNodes(h.cfg.EphemeralNodeInactivityTimeout)
 	}
 }
 
-// expireExpiredMachines expires machines that have an explicit expiry set
+// expireExpiredMachines expires nodes that have an explicit expiry set
 // after that expiry time has passed.
 func (h *Headscale) expireExpiredMachines(intervalMs int64) {
 	interval := time.Duration(intervalMs) * time.Millisecond
@@ -238,7 +238,7 @@ func (h *Headscale) expireExpiredMachines(intervalMs int64) {
 	lastCheck := time.Unix(0, 0)
 
 	for range ticker.C {
-		lastCheck = h.db.ExpireExpiredMachines(lastCheck)
+		lastCheck = h.db.ExpireExpiredNodes(lastCheck)
 	}
 }
 
diff --git a/hscontrol/auth.go b/hscontrol/auth.go
index e9121203c5..b75636597f 100644
--- a/hscontrol/auth.go
+++ b/hscontrol/auth.go
@@ -27,9 +27,9 @@ func (h *Headscale) handleRegister(
 	isNoise bool,
 ) {
 	now := time.Now().UTC()
-	machine, err := h.db.GetMachineByAnyKey(machineKey, registerRequest.NodeKey, registerRequest.OldNodeKey)
+	node, err := h.db.GetNodeByAnyKey(machineKey, registerRequest.NodeKey, registerRequest.OldNodeKey)
 	if errors.Is(err, gorm.ErrRecordNotFound) {
-		// If the machine has AuthKey set, handle registration via PreAuthKeys
+		// If the node has AuthKey set, handle registration via PreAuthKeys
 		if registerRequest.Auth.AuthKey != "" {
 			h.handleAuthKey(writer, registerRequest, machineKey, isNoise)
 
@@ -40,7 +40,7 @@ func (h *Headscale) handleRegister(
 		//
 		// TODO(juan): We could use this field to improve our protocol implementation,
 		// and hold the request until the client closes it, or the interactive
-		// login is completed (i.e., the user registers the machine).
+		// login is completed (i.e., the user registers the node).
 		// This is not implemented yet, as it is no strictly required. The only side-effect
 		// is that the client will hammer headscale with requests until it gets a
 		// successful RegisterResponse.
@@ -48,19 +48,19 @@ func (h *Headscale) handleRegister(
 			if _, ok := h.registrationCache.Get(util.NodePublicKeyStripPrefix(registerRequest.NodeKey)); ok {
 				log.Debug().
 					Caller().
-					Str("machine", registerRequest.Hostinfo.Hostname).
+					Str("node", registerRequest.Hostinfo.Hostname).
 					Str("machine_key", machineKey.ShortString()).
 					Str("node_key", registerRequest.NodeKey.ShortString()).
 					Str("node_key_old", registerRequest.OldNodeKey.ShortString()).
 					Str("follow_up", registerRequest.Followup).
 					Bool("noise", isNoise).
-					Msg("Machine is waiting for interactive login")
+					Msg("Node is waiting for interactive login")
 
 				select {
 				case <-req.Context().Done():
 					return
 				case <-time.After(registrationHoldoff):
-					h.handleNewMachine(writer, registerRequest, machineKey, isNoise)
+					h.handleNewNode(writer, registerRequest, machineKey, isNoise)
 
 					return
 				}
@@ -69,13 +69,13 @@ func (h *Headscale) handleRegister(
 
 		log.Info().
 			Caller().
-			Str("machine", registerRequest.Hostinfo.Hostname).
+			Str("node", registerRequest.Hostinfo.Hostname).
 			Str("machine_key", machineKey.ShortString()).
 			Str("node_key", registerRequest.NodeKey.ShortString()).
 			Str("node_key_old", registerRequest.OldNodeKey.ShortString()).
 			Str("follow_up", registerRequest.Followup).
 			Bool("noise", isNoise).
-			Msg("New machine not yet in the database")
+			Msg("New node not yet in the database")
 
 		givenName, err := h.db.GenerateGivenName(
 			machineKey.String(),
@@ -92,11 +92,11 @@ func (h *Headscale) handleRegister(
 			return
 		}
 
-		// The machine did not have a key to authenticate, which means
+		// The node did not have a key to authenticate, which means
 		// that we rely on a method that calls back some how (OpenID or CLI)
-		// We create the machine and then keep it around until a callback
+		// We create the node and then keep it around until a callback
 		// happens
-		newMachine := types.Machine{
+		newNode := types.Node{
 			MachineKey: util.MachinePublicKeyStripPrefix(machineKey),
 			Hostname:   registerRequest.Hostinfo.Hostname,
 			GivenName:  givenName,
@@ -109,41 +109,41 @@ func (h *Headscale) handleRegister(
 			log.Trace().
 				Caller().
 				Bool("noise", isNoise).
-				Str("machine", registerRequest.Hostinfo.Hostname).
+				Str("node", registerRequest.Hostinfo.Hostname).
 				Time("expiry", registerRequest.Expiry).
 				Msg("Non-zero expiry time requested")
-			newMachine.Expiry = &registerRequest.Expiry
+			newNode.Expiry = &registerRequest.Expiry
 		}
 
 		h.registrationCache.Set(
-			newMachine.NodeKey,
-			newMachine,
+			newNode.NodeKey,
+			newNode,
 			registerCacheExpiration,
 		)
 
-		h.handleNewMachine(writer, registerRequest, machineKey, isNoise)
+		h.handleNewNode(writer, registerRequest, machineKey, isNoise)
 
 		return
 	}
 
-	// The machine is already in the DB. This could mean one of the following:
-	// - The machine is authenticated and ready to /map
+	// The node is already in the DB. This could mean one of the following:
+	// - The node is authenticated and ready to /map
 	// - We are doing a key refresh
-	// - The machine is logged out (or expired) and pending to be authorized. TODO(juan): We need to keep alive the connection here
-	if machine != nil {
+	// - The node is logged out (or expired) and pending to be authorized. TODO(juan): We need to keep alive the connection here
+	if node != nil {
 		// (juan): For a while we had a bug where we were not storing the MachineKey for the nodes using the TS2021,
 		// due to a misunderstanding of the protocol https://github.com/juanfont/headscale/issues/1054
-		// So if we have a not valid MachineKey (but we were able to fetch the machine with the NodeKeys), we update it.
+		// So if we have a not valid MachineKey (but we were able to fetch the node with the NodeKeys), we update it.
 		var storedMachineKey key.MachinePublic
 		err = storedMachineKey.UnmarshalText(
-			[]byte(util.MachinePublicKeyEnsurePrefix(machine.MachineKey)),
+			[]byte(util.MachinePublicKeyEnsurePrefix(node.MachineKey)),
 		)
 		if err != nil || storedMachineKey.IsZero() {
-			if err := h.db.MachineSetMachineKey(machine, machineKey); err != nil {
+			if err := h.db.NodeSetMachineKey(node, machineKey); err != nil {
 				log.Error().
 					Caller().
 					Str("func", "RegistrationHandler").
-					Str("machine", machine.Hostname).
+					Str("node", node.Hostname).
 					Err(err).
 					Msg("Error saving machine key to database")
 
@@ -154,34 +154,34 @@ func (h *Headscale) handleRegister(
 		// If the NodeKey stored in headscale is the same as the key presented in a registration
 		// request, then we have a node that is either:
 		// - Trying to log out (sending a expiry in the past)
-		// - A valid, registered machine, looking for /map
-		// - Expired machine wanting to reauthenticate
-		if machine.NodeKey == util.NodePublicKeyStripPrefix(registerRequest.NodeKey) {
+		// - A valid, registered node, looking for /map
+		// - Expired node wanting to reauthenticate
+		if node.NodeKey == util.NodePublicKeyStripPrefix(registerRequest.NodeKey) {
 			// The client sends an Expiry in the past if the client is requesting to expire the key (aka logout)
 			//   https://github.com/tailscale/tailscale/blob/main/tailcfg/tailcfg.go#L648
 			if !registerRequest.Expiry.IsZero() &&
 				registerRequest.Expiry.UTC().Before(now) {
-				h.handleMachineLogOut(writer, *machine, machineKey, isNoise)
+				h.handleNodeLogOut(writer, *node, machineKey, isNoise)
 
 				return
 			}
 
-			// If machine is not expired, and it is register, we have a already accepted this machine,
+			// If node is not expired, and it is register, we have a already accepted this node,
 			// let it proceed with a valid registration
-			if !machine.IsExpired() {
-				h.handleMachineWithValidRegistration(writer, *machine, machineKey, isNoise)
+			if !node.IsExpired() {
+				h.handleNodeWithValidRegistration(writer, *node, machineKey, isNoise)
 
 				return
 			}
 		}
 
 		// The NodeKey we have matches OldNodeKey, which means this is a refresh after a key expiration
-		if machine.NodeKey == util.NodePublicKeyStripPrefix(registerRequest.OldNodeKey) &&
-			!machine.IsExpired() {
-			h.handleMachineKeyRefresh(
+		if node.NodeKey == util.NodePublicKeyStripPrefix(registerRequest.OldNodeKey) &&
+			!node.IsExpired() {
+			h.handleNodeKeyRefresh(
 				writer,
 				registerRequest,
-				*machine,
+				*node,
 				machineKey,
 				isNoise,
 			)
@@ -197,20 +197,20 @@ func (h *Headscale) handleRegister(
 			}
 		}
 
-		// The machine has expired or it is logged out
-		h.handleMachineExpiredOrLoggedOut(writer, registerRequest, *machine, machineKey, isNoise)
+		// The node has expired or it is logged out
+		h.handleNodeExpiredOrLoggedOut(writer, registerRequest, *node, machineKey, isNoise)
 
 		// TODO(juan): RegisterRequest includes an Expiry time, that we could optionally use
-		machine.Expiry = &time.Time{}
+		node.Expiry = &time.Time{}
 
 		// If we are here it means the client needs to be reauthorized,
 		// we need to make sure the NodeKey matches the one in the request
 		// TODO(juan): What happens when using fast user switching between two
 		// headscale-managed tailnets?
-		machine.NodeKey = util.NodePublicKeyStripPrefix(registerRequest.NodeKey)
+		node.NodeKey = util.NodePublicKeyStripPrefix(registerRequest.NodeKey)
 		h.registrationCache.Set(
 			util.NodePublicKeyStripPrefix(registerRequest.NodeKey),
-			*machine,
+			*node,
 			registerCacheExpiration,
 		)
 
@@ -231,7 +231,7 @@ func (h *Headscale) handleAuthKey(
 ) {
 	log.Debug().
 		Caller().
-		Str("machine", registerRequest.Hostinfo.Hostname).
+		Str("node", registerRequest.Hostinfo.Hostname).
 		Bool("noise", isNoise).
 		Msgf("Processing auth key for %s", registerRequest.Hostinfo.Hostname)
 	resp := tailcfg.RegisterResponse{}
@@ -241,7 +241,7 @@ func (h *Headscale) handleAuthKey(
 		log.Error().
 			Caller().
 			Bool("noise", isNoise).
-			Str("machine", registerRequest.Hostinfo.Hostname).
+			Str("node", registerRequest.Hostinfo.Hostname).
 			Err(err).
 			Msg("Failed authentication via AuthKey")
 		resp.MachineAuthorized = false
@@ -251,11 +251,11 @@ func (h *Headscale) handleAuthKey(
 			log.Error().
 				Caller().
 				Bool("noise", isNoise).
-				Str("machine", registerRequest.Hostinfo.Hostname).
+				Str("node", registerRequest.Hostinfo.Hostname).
 				Err(err).
 				Msg("Cannot encode message")
 			http.Error(writer, "Internal server error", http.StatusInternalServerError)
-			machineRegistrations.WithLabelValues("new", util.RegisterMethodAuthKey, "error", pak.User.Name).
+			nodeRegistrations.WithLabelValues("new", util.RegisterMethodAuthKey, "error", pak.User.Name).
 				Inc()
 
 			return
@@ -275,14 +275,14 @@ func (h *Headscale) handleAuthKey(
 		log.Error().
 			Caller().
 			Bool("noise", isNoise).
-			Str("machine", registerRequest.Hostinfo.Hostname).
+			Str("node", registerRequest.Hostinfo.Hostname).
 			Msg("Failed authentication via AuthKey")
 
 		if pak != nil {
-			machineRegistrations.WithLabelValues("new", util.RegisterMethodAuthKey, "error", pak.User.Name).
+			nodeRegistrations.WithLabelValues("new", util.RegisterMethodAuthKey, "error", pak.User.Name).
 				Inc()
 		} else {
-			machineRegistrations.WithLabelValues("new", util.RegisterMethodAuthKey, "error", "unknown").Inc()
+			nodeRegistrations.WithLabelValues("new", util.RegisterMethodAuthKey, "error", "unknown").Inc()
 		}
 
 		return
@@ -291,33 +291,33 @@ func (h *Headscale) handleAuthKey(
 	log.Debug().
 		Caller().
 		Bool("noise", isNoise).
-		Str("machine", registerRequest.Hostinfo.Hostname).
+		Str("node", registerRequest.Hostinfo.Hostname).
 		Msg("Authentication key was valid, proceeding to acquire IP addresses")
 
 	nodeKey := util.NodePublicKeyStripPrefix(registerRequest.NodeKey)
 
-	// retrieve machine information if it exist
+	// retrieve node information if it exist
 	// The error is not important, because if it does not
-	// exist, then this is a new machine and we will move
+	// exist, then this is a new node and we will move
 	// on to registration.
-	machine, _ := h.db.GetMachineByAnyKey(machineKey, registerRequest.NodeKey, registerRequest.OldNodeKey)
-	if machine != nil {
+	node, _ := h.db.GetNodeByAnyKey(machineKey, registerRequest.NodeKey, registerRequest.OldNodeKey)
+	if node != nil {
 		log.Trace().
 			Caller().
 			Bool("noise", isNoise).
-			Str("machine", machine.Hostname).
-			Msg("machine was already registered before, refreshing with new auth key")
+			Str("node", node.Hostname).
+			Msg("node was already registered before, refreshing with new auth key")
 
-		machine.NodeKey = nodeKey
-		machine.AuthKeyID = uint(pak.ID)
-		err := h.db.MachineSetExpiry(machine, registerRequest.Expiry)
+		node.NodeKey = nodeKey
+		node.AuthKeyID = uint(pak.ID)
+		err := h.db.NodeSetExpiry(node, registerRequest.Expiry)
 		if err != nil {
 			log.Error().
 				Caller().
 				Bool("noise", isNoise).
-				Str("machine", machine.Hostname).
+				Str("node", node.Hostname).
 				Err(err).
-				Msg("Failed to refresh machine")
+				Msg("Failed to refresh node")
 
 			return
 		}
@@ -325,16 +325,16 @@ func (h *Headscale) handleAuthKey(
 		aclTags := pak.Proto().AclTags
 		if len(aclTags) > 0 {
 			// This conditional preserves the existing behaviour, although SaaS would reset the tags on auth-key login
-			err = h.db.SetTags(machine, aclTags)
+			err = h.db.SetTags(node, aclTags)
 
 			if err != nil {
 				log.Error().
 					Caller().
 					Bool("noise", isNoise).
-					Str("machine", machine.Hostname).
+					Str("node", node.Hostname).
 					Strs("aclTags", aclTags).
 					Err(err).
-					Msg("Failed to set tags after refreshing machine")
+					Msg("Failed to set tags after refreshing node")
 
 				return
 			}
@@ -355,7 +355,7 @@ func (h *Headscale) handleAuthKey(
 			return
 		}
 
-		machineToRegister := types.Machine{
+		nodeToRegister := types.Node{
 			Hostname:       registerRequest.Hostinfo.Hostname,
 			GivenName:      givenName,
 			UserID:         pak.User.ID,
@@ -368,16 +368,16 @@ func (h *Headscale) handleAuthKey(
 			ForcedTags:     pak.Proto().AclTags,
 		}
 
-		machine, err = h.db.RegisterMachine(
-			machineToRegister,
+		node, err = h.db.RegisterNode(
+			nodeToRegister,
 		)
 		if err != nil {
 			log.Error().
 				Caller().
 				Bool("noise", isNoise).
 				Err(err).
-				Msg("could not register machine")
-			machineRegistrations.WithLabelValues("new", util.RegisterMethodAuthKey, "error", pak.User.Name).
+				Msg("could not register node")
+			nodeRegistrations.WithLabelValues("new", util.RegisterMethodAuthKey, "error", pak.User.Name).
 				Inc()
 			http.Error(writer, "Internal server error", http.StatusInternalServerError)
 
@@ -392,7 +392,7 @@ func (h *Headscale) handleAuthKey(
 			Bool("noise", isNoise).
 			Err(err).
 			Msg("Failed to use pre-auth key")
-		machineRegistrations.WithLabelValues("new", util.RegisterMethodAuthKey, "error", pak.User.Name).
+		nodeRegistrations.WithLabelValues("new", util.RegisterMethodAuthKey, "error", pak.User.Name).
 			Inc()
 		http.Error(writer, "Internal server error", http.StatusInternalServerError)
 
@@ -410,16 +410,16 @@ func (h *Headscale) handleAuthKey(
 		log.Error().
 			Caller().
 			Bool("noise", isNoise).
-			Str("machine", registerRequest.Hostinfo.Hostname).
+			Str("node", registerRequest.Hostinfo.Hostname).
 			Err(err).
 			Msg("Cannot encode message")
-		machineRegistrations.WithLabelValues("new", util.RegisterMethodAuthKey, "error", pak.User.Name).
+		nodeRegistrations.WithLabelValues("new", util.RegisterMethodAuthKey, "error", pak.User.Name).
 			Inc()
 		http.Error(writer, "Internal server error", http.StatusInternalServerError)
 
 		return
 	}
-	machineRegistrations.WithLabelValues("new", util.RegisterMethodAuthKey, "success", pak.User.Name).
+	nodeRegistrations.WithLabelValues("new", util.RegisterMethodAuthKey, "success", pak.User.Name).
 		Inc()
 	writer.Header().Set("Content-Type", "application/json; charset=utf-8")
 	writer.WriteHeader(http.StatusOK)
@@ -434,14 +434,14 @@ func (h *Headscale) handleAuthKey(
 
 	log.Info().
 		Bool("noise", isNoise).
-		Str("machine", registerRequest.Hostinfo.Hostname).
-		Str("ips", strings.Join(machine.IPAddresses.StringSlice(), ", ")).
+		Str("node", registerRequest.Hostinfo.Hostname).
+		Str("ips", strings.Join(node.IPAddresses.StringSlice(), ", ")).
 		Msg("Successfully authenticated via AuthKey")
 }
 
-// handleNewMachine exposes for both legacy and Noise the functionality to get a URL
-// for authorizing the machine. This url is then showed to the user by the local Tailscale client.
-func (h *Headscale) handleNewMachine(
+// handleNewNode exposes for both legacy and Noise the functionality to get a URL
+// for authorizing the node. This url is then showed to the user by the local Tailscale client.
+func (h *Headscale) handleNewNode(
 	writer http.ResponseWriter,
 	registerRequest tailcfg.RegisterRequest,
 	machineKey key.MachinePublic,
@@ -449,11 +449,11 @@ func (h *Headscale) handleNewMachine(
 ) {
 	resp := tailcfg.RegisterResponse{}
 
-	// The machine registration is new, redirect the client to the registration URL
+	// The node registration is new, redirect the client to the registration URL
 	log.Debug().
 		Caller().
 		Bool("noise", isNoise).
-		Str("machine", registerRequest.Hostinfo.Hostname).
+		Str("node", registerRequest.Hostinfo.Hostname).
 		Msg("The node seems to be new, sending auth url")
 
 	if h.oauth2Config != nil {
@@ -495,13 +495,13 @@ func (h *Headscale) handleNewMachine(
 		Caller().
 		Bool("noise", isNoise).
 		Str("AuthURL", resp.AuthURL).
-		Str("machine", registerRequest.Hostinfo.Hostname).
+		Str("node", registerRequest.Hostinfo.Hostname).
 		Msg("Successfully sent auth url")
 }
 
-func (h *Headscale) handleMachineLogOut(
+func (h *Headscale) handleNodeLogOut(
 	writer http.ResponseWriter,
-	machine types.Machine,
+	node types.Node,
 	machineKey key.MachinePublic,
 	isNoise bool,
 ) {
@@ -509,17 +509,17 @@ func (h *Headscale) handleMachineLogOut(
 
 	log.Info().
 		Bool("noise", isNoise).
-		Str("machine", machine.Hostname).
+		Str("node", node.Hostname).
 		Msg("Client requested logout")
 
 	now := time.Now()
-	err := h.db.MachineSetExpiry(&machine, now)
+	err := h.db.NodeSetExpiry(&node, now)
 	if err != nil {
 		log.Error().
 			Caller().
 			Bool("noise", isNoise).
 			Err(err).
-			Msg("Failed to expire machine")
+			Msg("Failed to expire node")
 		http.Error(writer, "Internal server error", http.StatusInternalServerError)
 
 		return
@@ -528,7 +528,7 @@ func (h *Headscale) handleMachineLogOut(
 	resp.AuthURL = ""
 	resp.MachineAuthorized = false
 	resp.NodeKeyExpired = true
-	resp.User = *machine.User.TailscaleUser()
+	resp.User = *node.User.TailscaleUser()
 	respBody, err := mapper.MarshalResponse(resp, isNoise, h.privateKey2019, machineKey)
 	if err != nil {
 		log.Error().
@@ -554,13 +554,13 @@ func (h *Headscale) handleMachineLogOut(
 		return
 	}
 
-	if machine.IsEphemeral() {
-		err = h.db.DeleteMachine(&machine)
+	if node.IsEphemeral() {
+		err = h.db.DeleteNode(&node)
 		if err != nil {
 			log.Error().
 				Err(err).
-				Str("machine", machine.Hostname).
-				Msg("Cannot delete ephemeral machine from the database")
+				Str("node", node.Hostname).
+				Msg("Cannot delete ephemeral node from the database")
 		}
 
 		return
@@ -569,29 +569,29 @@ func (h *Headscale) handleMachineLogOut(
 	log.Info().
 		Caller().
 		Bool("noise", isNoise).
-		Str("machine", machine.Hostname).
+		Str("node", node.Hostname).
 		Msg("Successfully logged out")
 }
 
-func (h *Headscale) handleMachineWithValidRegistration(
+func (h *Headscale) handleNodeWithValidRegistration(
 	writer http.ResponseWriter,
-	machine types.Machine,
+	node types.Node,
 	machineKey key.MachinePublic,
 	isNoise bool,
 ) {
 	resp := tailcfg.RegisterResponse{}
 
-	// The machine registration is valid, respond with redirect to /map
+	// The node registration is valid, respond with redirect to /map
 	log.Debug().
 		Caller().
 		Bool("noise", isNoise).
-		Str("machine", machine.Hostname).
+		Str("node", node.Hostname).
 		Msg("Client is registered and we have the current NodeKey. All clear to /map")
 
 	resp.AuthURL = ""
 	resp.MachineAuthorized = true
-	resp.User = *machine.User.TailscaleUser()
-	resp.Login = *machine.User.TailscaleLogin()
+	resp.User = *node.User.TailscaleUser()
+	resp.Login = *node.User.TailscaleLogin()
 
 	respBody, err := mapper.MarshalResponse(resp, isNoise, h.privateKey2019, machineKey)
 	if err != nil {
@@ -600,13 +600,13 @@ func (h *Headscale) handleMachineWithValidRegistration(
 			Bool("noise", isNoise).
 			Err(err).
 			Msg("Cannot encode message")
-		machineRegistrations.WithLabelValues("update", "web", "error", machine.User.Name).
+		nodeRegistrations.WithLabelValues("update", "web", "error", node.User.Name).
 			Inc()
 		http.Error(writer, "Internal server error", http.StatusInternalServerError)
 
 		return
 	}
-	machineRegistrations.WithLabelValues("update", "web", "success", machine.User.Name).
+	nodeRegistrations.WithLabelValues("update", "web", "success", node.User.Name).
 		Inc()
 
 	writer.Header().Set("Content-Type", "application/json; charset=utf-8")
@@ -623,14 +623,14 @@ func (h *Headscale) handleMachineWithValidRegistration(
 	log.Info().
 		Caller().
 		Bool("noise", isNoise).
-		Str("machine", machine.Hostname).
-		Msg("Machine successfully authorized")
+		Str("node", node.Hostname).
+		Msg("Node successfully authorized")
 }
 
-func (h *Headscale) handleMachineKeyRefresh(
+func (h *Headscale) handleNodeKeyRefresh(
 	writer http.ResponseWriter,
 	registerRequest tailcfg.RegisterRequest,
-	machine types.Machine,
+	node types.Node,
 	machineKey key.MachinePublic,
 	isNoise bool,
 ) {
@@ -639,10 +639,10 @@ func (h *Headscale) handleMachineKeyRefresh(
 	log.Info().
 		Caller().
 		Bool("noise", isNoise).
-		Str("machine", machine.Hostname).
+		Str("node", node.Hostname).
 		Msg("We have the OldNodeKey in the database. This is a key refresh")
 
-	err := h.db.MachineSetNodeKey(&machine, registerRequest.NodeKey)
+	err := h.db.NodeSetNodeKey(&node, registerRequest.NodeKey)
 	if err != nil {
 		log.Error().
 			Caller().
@@ -654,7 +654,7 @@ func (h *Headscale) handleMachineKeyRefresh(
 	}
 
 	resp.AuthURL = ""
-	resp.User = *machine.User.TailscaleUser()
+	resp.User = *node.User.TailscaleUser()
 	respBody, err := mapper.MarshalResponse(resp, isNoise, h.privateKey2019, machineKey)
 	if err != nil {
 		log.Error().
@@ -683,14 +683,14 @@ func (h *Headscale) handleMachineKeyRefresh(
 		Bool("noise", isNoise).
 		Str("node_key", registerRequest.NodeKey.ShortString()).
 		Str("old_node_key", registerRequest.OldNodeKey.ShortString()).
-		Str("machine", machine.Hostname).
+		Str("node", node.Hostname).
 		Msg("Node key successfully refreshed")
 }
 
-func (h *Headscale) handleMachineExpiredOrLoggedOut(
+func (h *Headscale) handleNodeExpiredOrLoggedOut(
 	writer http.ResponseWriter,
 	registerRequest tailcfg.RegisterRequest,
-	machine types.Machine,
+	node types.Node,
 	machineKey key.MachinePublic,
 	isNoise bool,
 ) {
@@ -706,11 +706,11 @@ func (h *Headscale) handleMachineExpiredOrLoggedOut(
 	log.Trace().
 		Caller().
 		Bool("noise", isNoise).
-		Str("machine", machine.Hostname).
+		Str("node", node.Hostname).
 		Str("machine_key", machineKey.ShortString()).
 		Str("node_key", registerRequest.NodeKey.ShortString()).
 		Str("node_key_old", registerRequest.OldNodeKey.ShortString()).
-		Msg("Machine registration has expired or logged out. Sending a auth url to register")
+		Msg("Node registration has expired or logged out. Sending a auth url to register")
 
 	if h.oauth2Config != nil {
 		resp.AuthURL = fmt.Sprintf("%s/oidc/register/%s",
@@ -729,13 +729,13 @@ func (h *Headscale) handleMachineExpiredOrLoggedOut(
 			Bool("noise", isNoise).
 			Err(err).
 			Msg("Cannot encode message")
-		machineRegistrations.WithLabelValues("reauth", "web", "error", machine.User.Name).
+		nodeRegistrations.WithLabelValues("reauth", "web", "error", node.User.Name).
 			Inc()
 		http.Error(writer, "Internal server error", http.StatusInternalServerError)
 
 		return
 	}
-	machineRegistrations.WithLabelValues("reauth", "web", "success", machine.User.Name).
+	nodeRegistrations.WithLabelValues("reauth", "web", "success", node.User.Name).
 		Inc()
 
 	writer.Header().Set("Content-Type", "application/json; charset=utf-8")
@@ -755,6 +755,6 @@ func (h *Headscale) handleMachineExpiredOrLoggedOut(
 		Str("machine_key", machineKey.ShortString()).
 		Str("node_key", registerRequest.NodeKey.ShortString()).
 		Str("node_key_old", registerRequest.OldNodeKey.ShortString()).
-		Str("machine", machine.Hostname).
-		Msg("Machine logged out. Sent AuthURL for reauthentication")
+		Str("node", node.Hostname).
+		Msg("Node logged out. Sent AuthURL for reauthentication")
 }
diff --git a/hscontrol/auth_legacy.go b/hscontrol/auth_legacy.go
index e816b6122f..f7e0382f87 100644
--- a/hscontrol/auth_legacy.go
+++ b/hscontrol/auth_legacy.go
@@ -39,7 +39,7 @@ func (h *Headscale) RegistrationHandler(
 			Caller().
 			Err(err).
 			Msg("Cannot parse machine key")
-		machineRegistrations.WithLabelValues("unknown", "web", "error", "unknown").Inc()
+		nodeRegistrations.WithLabelValues("unknown", "web", "error", "unknown").Inc()
 		http.Error(writer, "Cannot parse machine key", http.StatusBadRequest)
 
 		return
@@ -51,7 +51,7 @@ func (h *Headscale) RegistrationHandler(
 			Caller().
 			Err(err).
 			Msg("Cannot decode message")
-		machineRegistrations.WithLabelValues("unknown", "web", "error", "unknown").Inc()
+		nodeRegistrations.WithLabelValues("unknown", "web", "error", "unknown").Inc()
 		http.Error(writer, "Cannot decode message", http.StatusBadRequest)
 
 		return
diff --git a/hscontrol/auth_noise.go b/hscontrol/auth_noise.go
index 54bea1c515..19a2c65f75 100644
--- a/hscontrol/auth_noise.go
+++ b/hscontrol/auth_noise.go
@@ -9,7 +9,7 @@ import (
 	"tailscale.com/tailcfg"
 )
 
-// // NoiseRegistrationHandler handles the actual registration process of a machine.
+// // NoiseRegistrationHandler handles the actual registration process of a node.
 func (ns *noiseServer) NoiseRegistrationHandler(
 	writer http.ResponseWriter,
 	req *http.Request,
@@ -33,7 +33,7 @@ func (ns *noiseServer) NoiseRegistrationHandler(
 			Caller().
 			Err(err).
 			Msg("Cannot parse RegisterRequest")
-		machineRegistrations.WithLabelValues("unknown", "web", "error", "unknown").Inc()
+		nodeRegistrations.WithLabelValues("unknown", "web", "error", "unknown").Inc()
 		http.Error(writer, "Internal error", http.StatusInternalServerError)
 
 		return
diff --git a/hscontrol/db/addresses.go b/hscontrol/db/addresses.go
index 1a7d35defc..beccf84379 100644
--- a/hscontrol/db/addresses.go
+++ b/hscontrol/db/addresses.go
@@ -17,8 +17,8 @@ import (
 
 var ErrCouldNotAllocateIP = errors.New("could not find any suitable IP")
 
-func (hsdb *HSDatabase) getAvailableIPs() (types.MachineAddresses, error) {
-	var ips types.MachineAddresses
+func (hsdb *HSDatabase) getAvailableIPs() (types.NodeAddresses, error) {
+	var ips types.NodeAddresses
 	var err error
 	for _, ipPrefix := range hsdb.ipPrefixes {
 		var ip *netip.Addr
@@ -69,11 +69,11 @@ func (hsdb *HSDatabase) getUsedIPs() (*netipx.IPSet, error) {
 	// but this was quick to get running and it should be enough
 	// to begin experimenting with a dual stack tailnet.
 	var addressesSlices []string
-	hsdb.db.Model(&types.Machine{}).Pluck("ip_addresses", &addressesSlices)
+	hsdb.db.Model(&types.Node{}).Pluck("ip_addresses", &addressesSlices)
 
 	var ips netipx.IPSetBuilder
 	for _, slice := range addressesSlices {
-		var machineAddresses types.MachineAddresses
+		var machineAddresses types.NodeAddresses
 		err := machineAddresses.Scan(slice)
 		if err != nil {
 			return &netipx.IPSet{}, fmt.Errorf(
diff --git a/hscontrol/db/addresses_test.go b/hscontrol/db/addresses_test.go
index 888dda369b..781fd896f7 100644
--- a/hscontrol/db/addresses_test.go
+++ b/hscontrol/db/addresses_test.go
@@ -30,21 +30,21 @@ func (s *Suite) TestGetUsedIps(c *check.C) {
 	pak, err := db.CreatePreAuthKey(user.Name, false, false, nil, nil)
 	c.Assert(err, check.IsNil)
 
-	_, err = db.GetMachine("test", "testmachine")
+	_, err = db.GetNode("test", "testnode")
 	c.Assert(err, check.NotNil)
 
-	machine := types.Machine{
+	node := types.Node{
 		ID:             0,
 		MachineKey:     "foo",
 		NodeKey:        "bar",
 		DiscoKey:       "faa",
-		Hostname:       "testmachine",
+		Hostname:       "testnode",
 		UserID:         user.ID,
 		RegisterMethod: util.RegisterMethodAuthKey,
 		AuthKeyID:      uint(pak.ID),
 		IPAddresses:    ips,
 	}
-	db.db.Save(&machine)
+	db.db.Save(&node)
 
 	usedIps, err := db.getUsedIPs()
 
@@ -58,11 +58,11 @@ func (s *Suite) TestGetUsedIps(c *check.C) {
 	c.Assert(usedIps.Equal(expectedIPSet), check.Equals, true)
 	c.Assert(usedIps.Contains(expected), check.Equals, true)
 
-	machine1, err := db.GetMachineByID(0)
+	node1, err := db.GetNodeByID(0)
 	c.Assert(err, check.IsNil)
 
-	c.Assert(len(machine1.IPAddresses), check.Equals, 1)
-	c.Assert(machine1.IPAddresses[0], check.Equals, expected)
+	c.Assert(len(node1.IPAddresses), check.Equals, 1)
+	c.Assert(node1.IPAddresses[0], check.Equals, expected)
 }
 
 func (s *Suite) TestGetMultiIp(c *check.C) {
@@ -78,21 +78,21 @@ func (s *Suite) TestGetMultiIp(c *check.C) {
 		pak, err := db.CreatePreAuthKey(user.Name, false, false, nil, nil)
 		c.Assert(err, check.IsNil)
 
-		_, err = db.GetMachine("test", "testmachine")
+		_, err = db.GetNode("test", "testnode")
 		c.Assert(err, check.NotNil)
 
-		machine := types.Machine{
+		node := types.Node{
 			ID:             uint64(index),
 			MachineKey:     "foo",
 			NodeKey:        "bar",
 			DiscoKey:       "faa",
-			Hostname:       "testmachine",
+			Hostname:       "testnode",
 			UserID:         user.ID,
 			RegisterMethod: util.RegisterMethodAuthKey,
 			AuthKeyID:      uint(pak.ID),
 			IPAddresses:    ips,
 		}
-		db.db.Save(&machine)
+		db.db.Save(&node)
 
 		db.ipAllocationMutex.Unlock()
 	}
@@ -119,20 +119,20 @@ func (s *Suite) TestGetMultiIp(c *check.C) {
 	c.Assert(usedIps.Contains(expected300), check.Equals, true)
 
 	// Check that we can read back the IPs
-	machine1, err := db.GetMachineByID(1)
+	node1, err := db.GetNodeByID(1)
 	c.Assert(err, check.IsNil)
-	c.Assert(len(machine1.IPAddresses), check.Equals, 1)
+	c.Assert(len(node1.IPAddresses), check.Equals, 1)
 	c.Assert(
-		machine1.IPAddresses[0],
+		node1.IPAddresses[0],
 		check.Equals,
 		netip.MustParseAddr("10.27.0.1"),
 	)
 
-	machine50, err := db.GetMachineByID(50)
+	node50, err := db.GetNodeByID(50)
 	c.Assert(err, check.IsNil)
-	c.Assert(len(machine50.IPAddresses), check.Equals, 1)
+	c.Assert(len(node50.IPAddresses), check.Equals, 1)
 	c.Assert(
-		machine50.IPAddresses[0],
+		node50.IPAddresses[0],
 		check.Equals,
 		netip.MustParseAddr("10.27.0.50"),
 	)
@@ -153,7 +153,7 @@ func (s *Suite) TestGetMultiIp(c *check.C) {
 	c.Assert(nextIP2[0].String(), check.Equals, expectedNextIP.String())
 }
 
-func (s *Suite) TestGetAvailableIpMachineWithoutIP(c *check.C) {
+func (s *Suite) TestGetAvailableIpNodeWithoutIP(c *check.C) {
 	ips, err := db.getAvailableIPs()
 	c.Assert(err, check.IsNil)
 
@@ -168,20 +168,20 @@ func (s *Suite) TestGetAvailableIpMachineWithoutIP(c *check.C) {
 	pak, err := db.CreatePreAuthKey(user.Name, false, false, nil, nil)
 	c.Assert(err, check.IsNil)
 
-	_, err = db.GetMachine("test", "testmachine")
+	_, err = db.GetNode("test", "testnode")
 	c.Assert(err, check.NotNil)
 
-	machine := types.Machine{
+	node := types.Node{
 		ID:             0,
 		MachineKey:     "foo",
 		NodeKey:        "bar",
 		DiscoKey:       "faa",
-		Hostname:       "testmachine",
+		Hostname:       "testnode",
 		UserID:         user.ID,
 		RegisterMethod: util.RegisterMethodAuthKey,
 		AuthKeyID:      uint(pak.ID),
 	}
-	db.db.Save(&machine)
+	db.db.Save(&node)
 
 	ips2, err := db.getAvailableIPs()
 	c.Assert(err, check.IsNil)
diff --git a/hscontrol/db/db.go b/hscontrol/db/db.go
index b309f593cc..51bb4023fb 100644
--- a/hscontrol/db/db.go
+++ b/hscontrol/db/db.go
@@ -78,49 +78,53 @@ func NewHeadscaleDatabase(
 
 	_ = dbConn.Migrator().RenameTable("namespaces", "users")
 
+	// the big rename from Machine to Node
+	_ = dbConn.Migrator().RenameTable("machines", "nodes")
+	_ = dbConn.Migrator().RenameColumn(&types.Route{}, "machine_id", "node_id")
+
 	err = dbConn.AutoMigrate(types.User{})
 	if err != nil {
 		return nil, err
 	}
 
-	_ = dbConn.Migrator().RenameColumn(&types.Machine{}, "namespace_id", "user_id")
+	_ = dbConn.Migrator().RenameColumn(&types.Node{}, "namespace_id", "user_id")
 	_ = dbConn.Migrator().RenameColumn(&types.PreAuthKey{}, "namespace_id", "user_id")
 
-	_ = dbConn.Migrator().RenameColumn(&types.Machine{}, "ip_address", "ip_addresses")
-	_ = dbConn.Migrator().RenameColumn(&types.Machine{}, "name", "hostname")
+	_ = dbConn.Migrator().RenameColumn(&types.Node{}, "ip_address", "ip_addresses")
+	_ = dbConn.Migrator().RenameColumn(&types.Node{}, "name", "hostname")
 
 	// GivenName is used as the primary source of DNS names, make sure
 	// the field is populated and normalized if it was not when the
-	// machine was registered.
-	_ = dbConn.Migrator().RenameColumn(&types.Machine{}, "nickname", "given_name")
+	// node was registered.
+	_ = dbConn.Migrator().RenameColumn(&types.Node{}, "nickname", "given_name")
 
-	// If the Machine table has a column for registered,
+	// If the MacNodehine table has a column for registered,
 	// find all occourences of "false" and drop them. Then
 	// remove the column.
-	if dbConn.Migrator().HasColumn(&types.Machine{}, "registered") {
+	if dbConn.Migrator().HasColumn(&types.Node{}, "registered") {
 		log.Info().
-			Msg(`Database has legacy "registered" column in machine, removing...`)
+			Msg(`Database has legacy "registered" column in node, removing...`)
 
-		machines := types.Machines{}
-		if err := dbConn.Not("registered").Find(&machines).Error; err != nil {
+		nodes := types.Nodes{}
+		if err := dbConn.Not("registered").Find(&nodes).Error; err != nil {
 			log.Error().Err(err).Msg("Error accessing db")
 		}
 
-		for _, machine := range machines {
+		for _, node := range nodes {
 			log.Info().
-				Str("machine", machine.Hostname).
-				Str("machine_key", machine.MachineKey).
-				Msg("Deleting unregistered machine")
-			if err := dbConn.Delete(&types.Machine{}, machine.ID).Error; err != nil {
+				Str("node", node.Hostname).
+				Str("machine_key", node.MachineKey).
+				Msg("Deleting unregistered node")
+			if err := dbConn.Delete(&types.Node{}, node.ID).Error; err != nil {
 				log.Error().
 					Err(err).
-					Str("machine", machine.Hostname).
-					Str("machine_key", machine.MachineKey).
-					Msg("Error deleting unregistered machine")
+					Str("node", node.Hostname).
+					Str("machine_key", node.MachineKey).
+					Msg("Error deleting unregistered node")
 			}
 		}
 
-		err := dbConn.Migrator().DropColumn(&types.Machine{}, "registered")
+		err := dbConn.Migrator().DropColumn(&types.Node{}, "registered")
 		if err != nil {
 			log.Error().Err(err).Msg("Error dropping registered column")
 		}
@@ -131,21 +135,21 @@ func NewHeadscaleDatabase(
 		return nil, err
 	}
 
-	if dbConn.Migrator().HasColumn(&types.Machine{}, "enabled_routes") {
-		log.Info().Msgf("Database has legacy enabled_routes column in machine, migrating...")
+	if dbConn.Migrator().HasColumn(&types.Node{}, "enabled_routes") {
+		log.Info().Msgf("Database has legacy enabled_routes column in node, migrating...")
 
-		type MachineAux struct {
+		type NodeAux struct {
 			ID            uint64
 			EnabledRoutes types.IPPrefixes
 		}
 
-		machinesAux := []MachineAux{}
-		err := dbConn.Table("machines").Select("id, enabled_routes").Scan(&machinesAux).Error
+		nodesAux := []NodeAux{}
+		err := dbConn.Table("nodes").Select("id, enabled_routes").Scan(&nodesAux).Error
 		if err != nil {
 			log.Fatal().Err(err).Msg("Error accessing db")
 		}
-		for _, machine := range machinesAux {
-			for _, prefix := range machine.EnabledRoutes {
+		for _, node := range nodesAux {
+			for _, prefix := range node.EnabledRoutes {
 				if err != nil {
 					log.Error().
 						Err(err).
@@ -155,8 +159,8 @@ func NewHeadscaleDatabase(
 					continue
 				}
 
-				err = dbConn.Preload("Machine").
-					Where("machine_id = ? AND prefix = ?", machine.ID, types.IPPrefix(prefix)).
+				err = dbConn.Preload("Node").
+					Where("node_id = ? AND prefix = ?", node.ID, types.IPPrefix(prefix)).
 					First(&types.Route{}).
 					Error
 				if err == nil {
@@ -168,7 +172,7 @@ func NewHeadscaleDatabase(
 				}
 
 				route := types.Route{
-					MachineID:  machine.ID,
+					NodeID:     node.ID,
 					Advertised: true,
 					Enabled:    true,
 					Prefix:     types.IPPrefix(prefix),
@@ -177,50 +181,50 @@ func NewHeadscaleDatabase(
 					log.Error().Err(err).Msg("Error creating route")
 				} else {
 					log.Info().
-						Uint64("machine_id", route.MachineID).
+						Uint64("node_id", route.NodeID).
 						Str("prefix", prefix.String()).
 						Msg("Route migrated")
 				}
 			}
 		}
 
-		err = dbConn.Migrator().DropColumn(&types.Machine{}, "enabled_routes")
+		err = dbConn.Migrator().DropColumn(&types.Node{}, "enabled_routes")
 		if err != nil {
 			log.Error().Err(err).Msg("Error dropping enabled_routes column")
 		}
 	}
 
-	err = dbConn.AutoMigrate(&types.Machine{})
+	err = dbConn.AutoMigrate(&types.Node{})
 	if err != nil {
 		return nil, err
 	}
 
-	if dbConn.Migrator().HasColumn(&types.Machine{}, "given_name") {
-		machines := types.Machines{}
-		if err := dbConn.Find(&machines).Error; err != nil {
+	if dbConn.Migrator().HasColumn(&types.Node{}, "given_name") {
+		nodes := types.Nodes{}
+		if err := dbConn.Find(&nodes).Error; err != nil {
 			log.Error().Err(err).Msg("Error accessing db")
 		}
 
-		for item, machine := range machines {
-			if machine.GivenName == "" {
+		for item, node := range nodes {
+			if node.GivenName == "" {
 				normalizedHostname, err := util.NormalizeToFQDNRulesConfigFromViper(
-					machine.Hostname,
+					node.Hostname,
 				)
 				if err != nil {
 					log.Error().
 						Caller().
-						Str("hostname", machine.Hostname).
+						Str("hostname", node.Hostname).
 						Err(err).
-						Msg("Failed to normalize machine hostname in DB migration")
+						Msg("Failed to normalize node hostname in DB migration")
 				}
 
-				err = db.RenameMachine(machines[item], normalizedHostname)
+				err = db.RenameNode(nodes[item], normalizedHostname)
 				if err != nil {
 					log.Error().
 						Caller().
-						Str("hostname", machine.Hostname).
+						Str("hostname", node.Hostname).
 						Err(err).
-						Msg("Failed to save normalized machine name in DB migration")
+						Msg("Failed to save normalized node name in DB migration")
 				}
 			}
 		}
diff --git a/hscontrol/db/machine.go b/hscontrol/db/machine.go
deleted file mode 100644
index c079f67779..0000000000
--- a/hscontrol/db/machine.go
+++ /dev/null
@@ -1,887 +0,0 @@
-package db
-
-import (
-	"errors"
-	"fmt"
-	"net/netip"
-	"sort"
-	"strings"
-	"time"
-
-	"github.com/juanfont/headscale/hscontrol/types"
-	"github.com/juanfont/headscale/hscontrol/util"
-	"github.com/patrickmn/go-cache"
-	"github.com/rs/zerolog/log"
-	"gorm.io/gorm"
-	"tailscale.com/tailcfg"
-	"tailscale.com/types/key"
-)
-
-const (
-	MachineGivenNameHashLength = 8
-	MachineGivenNameTrimSize   = 2
-)
-
-var (
-	ErrMachineNotFound                  = errors.New("machine not found")
-	ErrMachineRouteIsNotAvailable       = errors.New("route is not available on machine")
-	ErrMachineNotFoundRegistrationCache = errors.New(
-		"machine not found in registration cache",
-	)
-	ErrCouldNotConvertMachineInterface = errors.New("failed to convert machine interface")
-	ErrDifferentRegisteredUser         = errors.New(
-		"machine was previously registered with a different user",
-	)
-)
-
-// ListPeers returns all peers of machine, regardless of any Policy or if the node is expired.
-func (hsdb *HSDatabase) ListPeers(machine *types.Machine) (types.Machines, error) {
-	hsdb.mu.RLock()
-	defer hsdb.mu.RUnlock()
-
-	return hsdb.listPeers(machine)
-}
-
-func (hsdb *HSDatabase) listPeers(machine *types.Machine) (types.Machines, error) {
-	log.Trace().
-		Caller().
-		Str("machine", machine.Hostname).
-		Msg("Finding direct peers")
-
-	machines := types.Machines{}
-	if err := hsdb.db.
-		Preload("AuthKey").
-		Preload("AuthKey.User").
-		Preload("User").
-		Preload("Routes").
-		Where("node_key <> ?",
-			machine.NodeKey).Find(&machines).Error; err != nil {
-		return types.Machines{}, err
-	}
-
-	sort.Slice(machines, func(i, j int) bool { return machines[i].ID < machines[j].ID })
-
-	log.Trace().
-		Caller().
-		Str("machine", machine.Hostname).
-		Msgf("Found peers: %s", machines.String())
-
-	return machines, nil
-}
-
-func (hsdb *HSDatabase) ListMachines() ([]types.Machine, error) {
-	hsdb.mu.RLock()
-	defer hsdb.mu.RUnlock()
-
-	return hsdb.listMachines()
-}
-
-func (hsdb *HSDatabase) listMachines() ([]types.Machine, error) {
-	machines := []types.Machine{}
-	if err := hsdb.db.
-		Preload("AuthKey").
-		Preload("AuthKey.User").
-		Preload("User").
-		Preload("Routes").
-		Find(&machines).Error; err != nil {
-		return nil, err
-	}
-
-	return machines, nil
-}
-
-func (hsdb *HSDatabase) ListMachinesByGivenName(givenName string) (types.Machines, error) {
-	hsdb.mu.RLock()
-	defer hsdb.mu.RUnlock()
-
-	return hsdb.listMachinesByGivenName(givenName)
-}
-
-func (hsdb *HSDatabase) listMachinesByGivenName(givenName string) (types.Machines, error) {
-	machines := types.Machines{}
-	if err := hsdb.db.
-		Preload("AuthKey").
-		Preload("AuthKey.User").
-		Preload("User").
-		Preload("Routes").
-		Where("given_name = ?", givenName).Find(&machines).Error; err != nil {
-		return nil, err
-	}
-
-	return machines, nil
-}
-
-// GetMachine finds a Machine by name and user and returns the Machine struct.
-func (hsdb *HSDatabase) GetMachine(user string, name string) (*types.Machine, error) {
-	hsdb.mu.RLock()
-	defer hsdb.mu.RUnlock()
-
-	machines, err := hsdb.ListMachinesByUser(user)
-	if err != nil {
-		return nil, err
-	}
-
-	for _, m := range machines {
-		if m.Hostname == name {
-			return m, nil
-		}
-	}
-
-	return nil, ErrMachineNotFound
-}
-
-// GetMachineByGivenName finds a Machine by given name and user and returns the Machine struct.
-func (hsdb *HSDatabase) GetMachineByGivenName(
-	user string,
-	givenName string,
-) (*types.Machine, error) {
-	hsdb.mu.RLock()
-	defer hsdb.mu.RUnlock()
-
-	machine := types.Machine{}
-	if err := hsdb.db.
-		Preload("AuthKey").
-		Preload("AuthKey.User").
-		Preload("User").
-		Preload("Routes").
-		Where("given_name = ?", givenName).First(&machine).Error; err != nil {
-		return nil, err
-	}
-
-	return nil, ErrMachineNotFound
-}
-
-// GetMachineByID finds a Machine by ID and returns the Machine struct.
-func (hsdb *HSDatabase) GetMachineByID(id uint64) (*types.Machine, error) {
-	hsdb.mu.RLock()
-	defer hsdb.mu.RUnlock()
-
-	mach := types.Machine{}
-	if result := hsdb.db.
-		Preload("AuthKey").
-		Preload("AuthKey.User").
-		Preload("User").
-		Preload("Routes").
-		Find(&types.Machine{ID: id}).First(&mach); result.Error != nil {
-		return nil, result.Error
-	}
-
-	return &mach, nil
-}
-
-// GetMachineByMachineKey finds a Machine by its MachineKey and returns the Machine struct.
-func (hsdb *HSDatabase) GetMachineByMachineKey(
-	machineKey key.MachinePublic,
-) (*types.Machine, error) {
-	hsdb.mu.RLock()
-	defer hsdb.mu.RUnlock()
-
-	mach := types.Machine{}
-	if result := hsdb.db.
-		Preload("AuthKey").
-		Preload("AuthKey.User").
-		Preload("User").
-		Preload("Routes").
-		First(&mach, "machine_key = ?", util.MachinePublicKeyStripPrefix(machineKey)); result.Error != nil {
-		return nil, result.Error
-	}
-
-	return &mach, nil
-}
-
-// GetMachineByNodeKey finds a Machine by its current NodeKey.
-func (hsdb *HSDatabase) GetMachineByNodeKey(
-	nodeKey key.NodePublic,
-) (*types.Machine, error) {
-	hsdb.mu.RLock()
-	defer hsdb.mu.RUnlock()
-
-	machine := types.Machine{}
-	if result := hsdb.db.
-		Preload("AuthKey").
-		Preload("AuthKey.User").
-		Preload("User").
-		Preload("Routes").
-		First(&machine, "node_key = ?",
-			util.NodePublicKeyStripPrefix(nodeKey)); result.Error != nil {
-		return nil, result.Error
-	}
-
-	return &machine, nil
-}
-
-// GetMachineByAnyNodeKey finds a Machine by its MachineKey, its current NodeKey or the old one, and returns the Machine struct.
-func (hsdb *HSDatabase) GetMachineByAnyKey(
-	machineKey key.MachinePublic, nodeKey key.NodePublic, oldNodeKey key.NodePublic,
-) (*types.Machine, error) {
-	hsdb.mu.RLock()
-	defer hsdb.mu.RUnlock()
-
-	machine := types.Machine{}
-	if result := hsdb.db.
-		Preload("AuthKey").
-		Preload("AuthKey.User").
-		Preload("User").
-		Preload("Routes").
-		First(&machine, "machine_key = ? OR node_key = ? OR node_key = ?",
-			util.MachinePublicKeyStripPrefix(machineKey),
-			util.NodePublicKeyStripPrefix(nodeKey),
-			util.NodePublicKeyStripPrefix(oldNodeKey)); result.Error != nil {
-		return nil, result.Error
-	}
-
-	return &machine, nil
-}
-
-func (hsdb *HSDatabase) MachineReloadFromDatabase(machine *types.Machine) error {
-	hsdb.mu.RLock()
-	defer hsdb.mu.RUnlock()
-
-	if result := hsdb.db.Find(machine).First(&machine); result.Error != nil {
-		return result.Error
-	}
-
-	return nil
-}
-
-// SetTags takes a Machine struct pointer and update the forced tags.
-func (hsdb *HSDatabase) SetTags(
-	machine *types.Machine,
-	tags []string,
-) error {
-	hsdb.mu.Lock()
-	defer hsdb.mu.Unlock()
-
-	newTags := []string{}
-	for _, tag := range tags {
-		if !util.StringOrPrefixListContains(newTags, tag) {
-			newTags = append(newTags, tag)
-		}
-	}
-
-	if err := hsdb.db.Model(machine).Updates(types.Machine{
-		ForcedTags: newTags,
-	}).Error; err != nil {
-		return fmt.Errorf("failed to update tags for machine in the database: %w", err)
-	}
-
-	hsdb.notifier.NotifyWithIgnore(types.StateUpdate{
-		Type:    types.StatePeerChanged,
-		Changed: types.Machines{machine},
-	}, machine.MachineKey)
-
-	return nil
-}
-
-// RenameMachine takes a Machine struct and a new GivenName for the machines
-// and renames it.
-func (hsdb *HSDatabase) RenameMachine(machine *types.Machine, newName string) error {
-	hsdb.mu.Lock()
-	defer hsdb.mu.Unlock()
-
-	err := util.CheckForFQDNRules(
-		newName,
-	)
-	if err != nil {
-		log.Error().
-			Caller().
-			Str("func", "RenameMachine").
-			Str("machine", machine.Hostname).
-			Str("newName", newName).
-			Err(err).
-			Msg("failed to rename machine")
-
-		return err
-	}
-	machine.GivenName = newName
-
-	if err := hsdb.db.Model(machine).Updates(types.Machine{
-		GivenName: newName,
-	}).Error; err != nil {
-		return fmt.Errorf("failed to rename machine in the database: %w", err)
-	}
-
-	hsdb.notifier.NotifyWithIgnore(types.StateUpdate{
-		Type:    types.StatePeerChanged,
-		Changed: types.Machines{machine},
-	}, machine.MachineKey)
-
-	return nil
-}
-
-// MachineSetExpiry takes a Machine struct and  a new expiry time.
-func (hsdb *HSDatabase) MachineSetExpiry(machine *types.Machine, expiry time.Time) error {
-	hsdb.mu.Lock()
-	defer hsdb.mu.Unlock()
-
-	return hsdb.machineSetExpiry(machine, expiry)
-}
-
-func (hsdb *HSDatabase) machineSetExpiry(machine *types.Machine, expiry time.Time) error {
-	if err := hsdb.db.Model(machine).Updates(types.Machine{
-		Expiry: &expiry,
-	}).Error; err != nil {
-		return fmt.Errorf(
-			"failed to refresh machine (update expiration) in the database: %w",
-			err,
-		)
-	}
-
-	hsdb.notifier.NotifyWithIgnore(types.StateUpdate{
-		Type:    types.StatePeerChanged,
-		Changed: types.Machines{machine},
-	}, machine.MachineKey)
-
-	return nil
-}
-
-// DeleteMachine deletes a Machine from the database.
-func (hsdb *HSDatabase) DeleteMachine(machine *types.Machine) error {
-	hsdb.mu.Lock()
-	defer hsdb.mu.Unlock()
-
-	return hsdb.deleteMachine(machine)
-}
-
-func (hsdb *HSDatabase) deleteMachine(machine *types.Machine) error {
-	err := hsdb.deleteMachineRoutes(machine)
-	if err != nil {
-		return err
-	}
-
-	// Unscoped causes the machine to be fully removed from the database.
-	if err := hsdb.db.Unscoped().Delete(&machine).Error; err != nil {
-		return err
-	}
-
-	hsdb.notifier.NotifyAll(types.StateUpdate{
-		Type:    types.StatePeerRemoved,
-		Removed: []tailcfg.NodeID{tailcfg.NodeID(machine.ID)},
-	})
-
-	return nil
-}
-
-// UpdateLastSeen sets a machine's last seen field indicating that we
-// have recently communicating with this machine.
-// This is mostly used to indicate if a machine is online and is not
-// extremely important to make sure is fully correct and to avoid
-// holding up the hot path, does not contain any locks and isnt
-// concurrency safe. But that should be ok.
-func (hsdb *HSDatabase) UpdateLastSeen(machine *types.Machine) error {
-	return hsdb.db.Model(machine).Updates(types.Machine{
-		LastSeen: machine.LastSeen,
-	}).Error
-}
-
-func (hsdb *HSDatabase) RegisterMachineFromAuthCallback(
-	cache *cache.Cache,
-	nodeKeyStr string,
-	userName string,
-	machineExpiry *time.Time,
-	registrationMethod string,
-) (*types.Machine, error) {
-	hsdb.mu.Lock()
-	defer hsdb.mu.Unlock()
-
-	nodeKey := key.NodePublic{}
-	err := nodeKey.UnmarshalText([]byte(nodeKeyStr))
-	if err != nil {
-		return nil, err
-	}
-
-	log.Debug().
-		Str("nodeKey", nodeKey.ShortString()).
-		Str("userName", userName).
-		Str("registrationMethod", registrationMethod).
-		Str("expiresAt", fmt.Sprintf("%v", machineExpiry)).
-		Msg("Registering machine from API/CLI or auth callback")
-
-	if machineInterface, ok := cache.Get(util.NodePublicKeyStripPrefix(nodeKey)); ok {
-		if registrationMachine, ok := machineInterface.(types.Machine); ok {
-			user, err := hsdb.getUser(userName)
-			if err != nil {
-				return nil, fmt.Errorf(
-					"failed to find user in register machine from auth callback, %w",
-					err,
-				)
-			}
-
-			// Registration of expired machine with different user
-			if registrationMachine.ID != 0 &&
-				registrationMachine.UserID != user.ID {
-				return nil, ErrDifferentRegisteredUser
-			}
-
-			registrationMachine.UserID = user.ID
-			registrationMachine.RegisterMethod = registrationMethod
-
-			if machineExpiry != nil {
-				registrationMachine.Expiry = machineExpiry
-			}
-
-			machine, err := hsdb.registerMachine(
-				registrationMachine,
-			)
-
-			if err == nil {
-				cache.Delete(nodeKeyStr)
-			}
-
-			return machine, err
-		} else {
-			return nil, ErrCouldNotConvertMachineInterface
-		}
-	}
-
-	return nil, ErrMachineNotFoundRegistrationCache
-}
-
-// RegisterMachine is executed from the CLI to register a new Machine using its MachineKey.
-func (hsdb *HSDatabase) RegisterMachine(machine types.Machine) (*types.Machine, error) {
-	hsdb.mu.Lock()
-	defer hsdb.mu.Unlock()
-
-	return hsdb.registerMachine(machine)
-}
-
-func (hsdb *HSDatabase) registerMachine(machine types.Machine) (*types.Machine, error) {
-	log.Debug().
-		Str("machine", machine.Hostname).
-		Str("machine_key", machine.MachineKey).
-		Str("node_key", machine.NodeKey).
-		Str("user", machine.User.Name).
-		Msg("Registering machine")
-
-	// If the machine exists and we had already IPs for it, we just save it
-	// so we store the machine.Expire and machine.Nodekey that has been set when
-	// adding it to the registrationCache
-	if len(machine.IPAddresses) > 0 {
-		if err := hsdb.db.Save(&machine).Error; err != nil {
-			return nil, fmt.Errorf("failed register existing machine in the database: %w", err)
-		}
-
-		log.Trace().
-			Caller().
-			Str("machine", machine.Hostname).
-			Str("machine_key", machine.MachineKey).
-			Str("node_key", machine.NodeKey).
-			Str("user", machine.User.Name).
-			Msg("Machine authorized again")
-
-		return &machine, nil
-	}
-
-	hsdb.ipAllocationMutex.Lock()
-	defer hsdb.ipAllocationMutex.Unlock()
-
-	ips, err := hsdb.getAvailableIPs()
-	if err != nil {
-		log.Error().
-			Caller().
-			Err(err).
-			Str("machine", machine.Hostname).
-			Msg("Could not find IP for the new machine")
-
-		return nil, err
-	}
-
-	machine.IPAddresses = ips
-
-	if err := hsdb.db.Save(&machine).Error; err != nil {
-		return nil, fmt.Errorf("failed register(save) machine in the database: %w", err)
-	}
-
-	log.Trace().
-		Caller().
-		Str("machine", machine.Hostname).
-		Str("ip", strings.Join(ips.StringSlice(), ",")).
-		Msg("Machine registered with the database")
-
-	return &machine, nil
-}
-
-// MachineSetNodeKey sets the node key of a machine and saves it to the database.
-func (hsdb *HSDatabase) MachineSetNodeKey(machine *types.Machine, nodeKey key.NodePublic) error {
-	hsdb.mu.Lock()
-	defer hsdb.mu.Unlock()
-
-	if err := hsdb.db.Model(machine).Updates(types.Machine{
-		NodeKey: util.NodePublicKeyStripPrefix(nodeKey),
-	}).Error; err != nil {
-		return err
-	}
-
-	return nil
-}
-
-// MachineSetMachineKey sets the machine key of a machine and saves it to the database.
-func (hsdb *HSDatabase) MachineSetMachineKey(
-	machine *types.Machine,
-	machineKey key.MachinePublic,
-) error {
-	hsdb.mu.Lock()
-	defer hsdb.mu.Unlock()
-
-	if err := hsdb.db.Model(machine).Updates(types.Machine{
-		MachineKey: util.MachinePublicKeyStripPrefix(machineKey),
-	}).Error; err != nil {
-		return err
-	}
-
-	return nil
-}
-
-// MachineSave saves a machine object to the database, prefer to use a specific save method rather
-// than this. It is intended to be used when we are changing or.
-func (hsdb *HSDatabase) MachineSave(machine *types.Machine) error {
-	hsdb.mu.Lock()
-	defer hsdb.mu.Unlock()
-
-	if err := hsdb.db.Save(machine).Error; err != nil {
-		return err
-	}
-
-	return nil
-}
-
-// GetAdvertisedRoutes returns the routes that are be advertised by the given machine.
-func (hsdb *HSDatabase) GetAdvertisedRoutes(machine *types.Machine) ([]netip.Prefix, error) {
-	hsdb.mu.RLock()
-	defer hsdb.mu.RUnlock()
-
-	return hsdb.getAdvertisedRoutes(machine)
-}
-
-func (hsdb *HSDatabase) getAdvertisedRoutes(machine *types.Machine) ([]netip.Prefix, error) {
-	routes := types.Routes{}
-
-	err := hsdb.db.
-		Preload("Machine").
-		Where("machine_id = ? AND advertised = ?", machine.ID, true).Find(&routes).Error
-	if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
-		log.Error().
-			Caller().
-			Err(err).
-			Str("machine", machine.Hostname).
-			Msg("Could not get advertised routes for machine")
-
-		return nil, err
-	}
-
-	prefixes := []netip.Prefix{}
-	for _, route := range routes {
-		prefixes = append(prefixes, netip.Prefix(route.Prefix))
-	}
-
-	return prefixes, nil
-}
-
-// GetEnabledRoutes returns the routes that are enabled for the machine.
-func (hsdb *HSDatabase) GetEnabledRoutes(machine *types.Machine) ([]netip.Prefix, error) {
-	hsdb.mu.RLock()
-	defer hsdb.mu.RUnlock()
-
-	return hsdb.getEnabledRoutes(machine)
-}
-
-func (hsdb *HSDatabase) getEnabledRoutes(machine *types.Machine) ([]netip.Prefix, error) {
-	routes := types.Routes{}
-
-	err := hsdb.db.
-		Preload("Machine").
-		Where("machine_id = ? AND advertised = ? AND enabled = ?", machine.ID, true, true).
-		Find(&routes).Error
-	if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
-		log.Error().
-			Caller().
-			Err(err).
-			Str("machine", machine.Hostname).
-			Msg("Could not get enabled routes for machine")
-
-		return nil, err
-	}
-
-	prefixes := []netip.Prefix{}
-	for _, route := range routes {
-		prefixes = append(prefixes, netip.Prefix(route.Prefix))
-	}
-
-	return prefixes, nil
-}
-
-func (hsdb *HSDatabase) IsRoutesEnabled(machine *types.Machine, routeStr string) bool {
-	hsdb.mu.RLock()
-	defer hsdb.mu.RUnlock()
-
-	route, err := netip.ParsePrefix(routeStr)
-	if err != nil {
-		return false
-	}
-
-	enabledRoutes, err := hsdb.getEnabledRoutes(machine)
-	if err != nil {
-		log.Error().Err(err).Msg("Could not get enabled routes")
-
-		return false
-	}
-
-	for _, enabledRoute := range enabledRoutes {
-		if route == enabledRoute {
-			return true
-		}
-	}
-
-	return false
-}
-
-func OnlineMachineMap(peers types.Machines) map[tailcfg.NodeID]bool {
-	ret := make(map[tailcfg.NodeID]bool)
-
-	for _, peer := range peers {
-		ret[tailcfg.NodeID(peer.ID)] = peer.IsOnline()
-	}
-
-	return ret
-}
-
-func (hsdb *HSDatabase) ListOnlineMachines(
-	machine *types.Machine,
-) (map[tailcfg.NodeID]bool, error) {
-	hsdb.mu.RLock()
-	defer hsdb.mu.RUnlock()
-
-	peers, err := hsdb.listPeers(machine)
-	if err != nil {
-		return nil, err
-	}
-
-	return OnlineMachineMap(peers), nil
-}
-
-// enableRoutes enables new routes based on a list of new routes.
-func (hsdb *HSDatabase) enableRoutes(machine *types.Machine, routeStrs ...string) error {
-	newRoutes := make([]netip.Prefix, len(routeStrs))
-	for index, routeStr := range routeStrs {
-		route, err := netip.ParsePrefix(routeStr)
-		if err != nil {
-			return err
-		}
-
-		newRoutes[index] = route
-	}
-
-	advertisedRoutes, err := hsdb.getAdvertisedRoutes(machine)
-	if err != nil {
-		return err
-	}
-
-	for _, newRoute := range newRoutes {
-		if !util.StringOrPrefixListContains(advertisedRoutes, newRoute) {
-			return fmt.Errorf(
-				"route (%s) is not available on node %s: %w",
-				machine.Hostname,
-				newRoute, ErrMachineRouteIsNotAvailable,
-			)
-		}
-	}
-
-	// Separate loop so we don't leave things in a half-updated state
-	for _, prefix := range newRoutes {
-		route := types.Route{}
-		err := hsdb.db.Preload("Machine").
-			Where("machine_id = ? AND prefix = ?", machine.ID, types.IPPrefix(prefix)).
-			First(&route).Error
-		if err == nil {
-			route.Enabled = true
-
-			// Mark already as primary if there is only this node offering this subnet
-			// (and is not an exit route)
-			if !route.IsExitRoute() {
-				route.IsPrimary = hsdb.isUniquePrefix(route)
-			}
-
-			err = hsdb.db.Save(&route).Error
-			if err != nil {
-				return fmt.Errorf("failed to enable route: %w", err)
-			}
-		} else {
-			return fmt.Errorf("failed to find route: %w", err)
-		}
-	}
-
-	hsdb.notifier.NotifyWithIgnore(types.StateUpdate{
-		Type:    types.StatePeerChanged,
-		Changed: types.Machines{machine},
-	}, machine.MachineKey)
-
-	return nil
-}
-
-func generateGivenName(suppliedName string, randomSuffix bool) (string, error) {
-	normalizedHostname, err := util.NormalizeToFQDNRulesConfigFromViper(
-		suppliedName,
-	)
-	if err != nil {
-		return "", err
-	}
-
-	if randomSuffix {
-		// Trim if a hostname will be longer than 63 chars after adding the hash.
-		trimmedHostnameLength := util.LabelHostnameLength - MachineGivenNameHashLength - MachineGivenNameTrimSize
-		if len(normalizedHostname) > trimmedHostnameLength {
-			normalizedHostname = normalizedHostname[:trimmedHostnameLength]
-		}
-
-		suffix, err := util.GenerateRandomStringDNSSafe(MachineGivenNameHashLength)
-		if err != nil {
-			return "", err
-		}
-
-		normalizedHostname += "-" + suffix
-	}
-
-	return normalizedHostname, nil
-}
-
-func (hsdb *HSDatabase) GenerateGivenName(machineKey string, suppliedName string) (string, error) {
-	hsdb.mu.RLock()
-	defer hsdb.mu.RUnlock()
-
-	givenName, err := generateGivenName(suppliedName, false)
-	if err != nil {
-		return "", err
-	}
-
-	// Tailscale rules (may differ) https://tailscale.com/kb/1098/machine-names/
-	machines, err := hsdb.listMachinesByGivenName(givenName)
-	if err != nil {
-		return "", err
-	}
-
-	for _, machine := range machines {
-		if machine.MachineKey != machineKey && machine.GivenName == givenName {
-			postfixedName, err := generateGivenName(suppliedName, true)
-			if err != nil {
-				return "", err
-			}
-
-			givenName = postfixedName
-		}
-	}
-
-	return givenName, nil
-}
-
-func (hsdb *HSDatabase) ExpireEphemeralMachines(inactivityThreshhold time.Duration) {
-	hsdb.mu.Lock()
-	defer hsdb.mu.Unlock()
-
-	users, err := hsdb.listUsers()
-	if err != nil {
-		log.Error().Err(err).Msg("Error listing users")
-
-		return
-	}
-
-	for _, user := range users {
-		machines, err := hsdb.listMachinesByUser(user.Name)
-		if err != nil {
-			log.Error().
-				Err(err).
-				Str("user", user.Name).
-				Msg("Error listing machines in user")
-
-			return
-		}
-
-		expired := make([]tailcfg.NodeID, 0)
-		for idx, machine := range machines {
-			if machine.IsEphemeral() && machine.LastSeen != nil &&
-				time.Now().
-					After(machine.LastSeen.Add(inactivityThreshhold)) {
-				expired = append(expired, tailcfg.NodeID(machine.ID))
-
-				log.Info().
-					Str("machine", machine.Hostname).
-					Msg("Ephemeral client removed from database")
-
-				err = hsdb.deleteMachine(machines[idx])
-				if err != nil {
-					log.Error().
-						Err(err).
-						Str("machine", machine.Hostname).
-						Msg("🤮 Cannot delete ephemeral machine from the database")
-				}
-			}
-		}
-
-		if len(expired) > 0 {
-			hsdb.notifier.NotifyAll(types.StateUpdate{
-				Type:    types.StatePeerRemoved,
-				Removed: expired,
-			})
-		}
-	}
-}
-
-func (hsdb *HSDatabase) ExpireExpiredMachines(lastCheck time.Time) time.Time {
-	hsdb.mu.Lock()
-	defer hsdb.mu.Unlock()
-
-	// use the time of the start of the function to ensure we
-	// dont miss some machines by returning it _after_ we have
-	// checked everything.
-	started := time.Now()
-
-	users, err := hsdb.listUsers()
-	if err != nil {
-		log.Error().Err(err).Msg("Error listing users")
-
-		return time.Unix(0, 0)
-	}
-
-	for _, user := range users {
-		machines, err := hsdb.listMachinesByUser(user.Name)
-		if err != nil {
-			log.Error().
-				Err(err).
-				Str("user", user.Name).
-				Msg("Error listing machines in user")
-
-			return time.Unix(0, 0)
-		}
-
-		expired := make([]tailcfg.NodeID, 0)
-		for index, machine := range machines {
-			if machine.IsExpired() &&
-				machine.Expiry.After(lastCheck) {
-				expired = append(expired, tailcfg.NodeID(machine.ID))
-
-				now := time.Now()
-				err := hsdb.machineSetExpiry(machines[index], now)
-				if err != nil {
-					log.Error().
-						Err(err).
-						Str("machine", machine.Hostname).
-						Str("name", machine.GivenName).
-						Msg("🤮 Cannot expire machine")
-				} else {
-					log.Info().
-						Str("machine", machine.Hostname).
-						Str("name", machine.GivenName).
-						Msg("Machine successfully expired")
-				}
-			}
-		}
-
-		if len(expired) > 0 {
-			hsdb.notifier.NotifyAll(types.StateUpdate{
-				Type:    types.StatePeerRemoved,
-				Removed: expired,
-			})
-		}
-	}
-
-	return started
-}
diff --git a/hscontrol/db/node.go b/hscontrol/db/node.go
new file mode 100644
index 0000000000..da4836c76f
--- /dev/null
+++ b/hscontrol/db/node.go
@@ -0,0 +1,887 @@
+package db
+
+import (
+	"errors"
+	"fmt"
+	"net/netip"
+	"sort"
+	"strings"
+	"time"
+
+	"github.com/juanfont/headscale/hscontrol/types"
+	"github.com/juanfont/headscale/hscontrol/util"
+	"github.com/patrickmn/go-cache"
+	"github.com/rs/zerolog/log"
+	"gorm.io/gorm"
+	"tailscale.com/tailcfg"
+	"tailscale.com/types/key"
+)
+
+const (
+	NodeGivenNameHashLength = 8
+	NodeGivenNameTrimSize   = 2
+)
+
+var (
+	ErrNodeNotFound                  = errors.New("node not found")
+	ErrNodeRouteIsNotAvailable       = errors.New("route is not available on node")
+	ErrNodeNotFoundRegistrationCache = errors.New(
+		"node not found in registration cache",
+	)
+	ErrCouldNotConvertNodeInterface = errors.New("failed to convert node interface")
+	ErrDifferentRegisteredUser      = errors.New(
+		"node was previously registered with a different user",
+	)
+)
+
+// ListPeers returns all peers of node, regardless of any Policy or if the node is expired.
+func (hsdb *HSDatabase) ListPeers(node *types.Node) (types.Nodes, error) {
+	hsdb.mu.RLock()
+	defer hsdb.mu.RUnlock()
+
+	return hsdb.listPeers(node)
+}
+
+func (hsdb *HSDatabase) listPeers(node *types.Node) (types.Nodes, error) {
+	log.Trace().
+		Caller().
+		Str("node", node.Hostname).
+		Msg("Finding direct peers")
+
+	nodes := types.Nodes{}
+	if err := hsdb.db.
+		Preload("AuthKey").
+		Preload("AuthKey.User").
+		Preload("User").
+		Preload("Routes").
+		Where("node_key <> ?",
+			node.NodeKey).Find(&nodes).Error; err != nil {
+		return types.Nodes{}, err
+	}
+
+	sort.Slice(nodes, func(i, j int) bool { return nodes[i].ID < nodes[j].ID })
+
+	log.Trace().
+		Caller().
+		Str("node", node.Hostname).
+		Msgf("Found peers: %s", nodes.String())
+
+	return nodes, nil
+}
+
+func (hsdb *HSDatabase) ListNodes() ([]types.Node, error) {
+	hsdb.mu.RLock()
+	defer hsdb.mu.RUnlock()
+
+	return hsdb.listNodes()
+}
+
+func (hsdb *HSDatabase) listNodes() ([]types.Node, error) {
+	nodes := []types.Node{}
+	if err := hsdb.db.
+		Preload("AuthKey").
+		Preload("AuthKey.User").
+		Preload("User").
+		Preload("Routes").
+		Find(&nodes).Error; err != nil {
+		return nil, err
+	}
+
+	return nodes, nil
+}
+
+func (hsdb *HSDatabase) ListNodesByGivenName(givenName string) (types.Nodes, error) {
+	hsdb.mu.RLock()
+	defer hsdb.mu.RUnlock()
+
+	return hsdb.listNodesByGivenName(givenName)
+}
+
+func (hsdb *HSDatabase) listNodesByGivenName(givenName string) (types.Nodes, error) {
+	nodes := types.Nodes{}
+	if err := hsdb.db.
+		Preload("AuthKey").
+		Preload("AuthKey.User").
+		Preload("User").
+		Preload("Routes").
+		Where("given_name = ?", givenName).Find(&nodes).Error; err != nil {
+		return nil, err
+	}
+
+	return nodes, nil
+}
+
+// GetNode finds a Node by name and user and returns the Node struct.
+func (hsdb *HSDatabase) GetNode(user string, name string) (*types.Node, error) {
+	hsdb.mu.RLock()
+	defer hsdb.mu.RUnlock()
+
+	nodes, err := hsdb.ListNodesByUser(user)
+	if err != nil {
+		return nil, err
+	}
+
+	for _, m := range nodes {
+		if m.Hostname == name {
+			return m, nil
+		}
+	}
+
+	return nil, ErrNodeNotFound
+}
+
+// GetNodeByGivenName finds a Node by given name and user and returns the Node struct.
+func (hsdb *HSDatabase) GetNodeByGivenName(
+	user string,
+	givenName string,
+) (*types.Node, error) {
+	hsdb.mu.RLock()
+	defer hsdb.mu.RUnlock()
+
+	node := types.Node{}
+	if err := hsdb.db.
+		Preload("AuthKey").
+		Preload("AuthKey.User").
+		Preload("User").
+		Preload("Routes").
+		Where("given_name = ?", givenName).First(&node).Error; err != nil {
+		return nil, err
+	}
+
+	return nil, ErrNodeNotFound
+}
+
+// GetNodeByID finds a Node by ID and returns the Node struct.
+func (hsdb *HSDatabase) GetNodeByID(id uint64) (*types.Node, error) {
+	hsdb.mu.RLock()
+	defer hsdb.mu.RUnlock()
+
+	mach := types.Node{}
+	if result := hsdb.db.
+		Preload("AuthKey").
+		Preload("AuthKey.User").
+		Preload("User").
+		Preload("Routes").
+		Find(&types.Node{ID: id}).First(&mach); result.Error != nil {
+		return nil, result.Error
+	}
+
+	return &mach, nil
+}
+
+// GetNodeByMachineKey finds a Node by its MachineKey and returns the Node struct.
+func (hsdb *HSDatabase) GetNodeByMachineKey(
+	machineKey key.MachinePublic,
+) (*types.Node, error) {
+	hsdb.mu.RLock()
+	defer hsdb.mu.RUnlock()
+
+	mach := types.Node{}
+	if result := hsdb.db.
+		Preload("AuthKey").
+		Preload("AuthKey.User").
+		Preload("User").
+		Preload("Routes").
+		First(&mach, "machine_key = ?", util.MachinePublicKeyStripPrefix(machineKey)); result.Error != nil {
+		return nil, result.Error
+	}
+
+	return &mach, nil
+}
+
+// GetNodeByNodeKey finds a Node by its current NodeKey.
+func (hsdb *HSDatabase) GetNodeByNodeKey(
+	nodeKey key.NodePublic,
+) (*types.Node, error) {
+	hsdb.mu.RLock()
+	defer hsdb.mu.RUnlock()
+
+	node := types.Node{}
+	if result := hsdb.db.
+		Preload("AuthKey").
+		Preload("AuthKey.User").
+		Preload("User").
+		Preload("Routes").
+		First(&node, "node_key = ?",
+			util.NodePublicKeyStripPrefix(nodeKey)); result.Error != nil {
+		return nil, result.Error
+	}
+
+	return &node, nil
+}
+
+// GetNodeByAnyKey finds a Node by its MachineKey, its current NodeKey or the old one, and returns the Node struct.
+func (hsdb *HSDatabase) GetNodeByAnyKey(
+	machineKey key.MachinePublic, nodeKey key.NodePublic, oldNodeKey key.NodePublic,
+) (*types.Node, error) {
+	hsdb.mu.RLock()
+	defer hsdb.mu.RUnlock()
+
+	node := types.Node{}
+	if result := hsdb.db.
+		Preload("AuthKey").
+		Preload("AuthKey.User").
+		Preload("User").
+		Preload("Routes").
+		First(&node, "machine_key = ? OR node_key = ? OR node_key = ?",
+			util.MachinePublicKeyStripPrefix(machineKey),
+			util.NodePublicKeyStripPrefix(nodeKey),
+			util.NodePublicKeyStripPrefix(oldNodeKey)); result.Error != nil {
+		return nil, result.Error
+	}
+
+	return &node, nil
+}
+
+func (hsdb *HSDatabase) NodeReloadFromDatabase(node *types.Node) error {
+	hsdb.mu.RLock()
+	defer hsdb.mu.RUnlock()
+
+	if result := hsdb.db.Find(node).First(&node); result.Error != nil {
+		return result.Error
+	}
+
+	return nil
+}
+
+// SetTags takes a Node struct pointer and update the forced tags.
+func (hsdb *HSDatabase) SetTags(
+	node *types.Node,
+	tags []string,
+) error {
+	hsdb.mu.Lock()
+	defer hsdb.mu.Unlock()
+
+	newTags := []string{}
+	for _, tag := range tags {
+		if !util.StringOrPrefixListContains(newTags, tag) {
+			newTags = append(newTags, tag)
+		}
+	}
+
+	if err := hsdb.db.Model(node).Updates(types.Node{
+		ForcedTags: newTags,
+	}).Error; err != nil {
+		return fmt.Errorf("failed to update tags for node in the database: %w", err)
+	}
+
+	hsdb.notifier.NotifyWithIgnore(types.StateUpdate{
+		Type:    types.StatePeerChanged,
+		Changed: types.Nodes{node},
+	}, node.MachineKey)
+
+	return nil
+}
+
+// RenameNode takes a Node struct and a new GivenName for the nodes
+// and renames it.
+func (hsdb *HSDatabase) RenameNode(node *types.Node, newName string) error {
+	hsdb.mu.Lock()
+	defer hsdb.mu.Unlock()
+
+	err := util.CheckForFQDNRules(
+		newName,
+	)
+	if err != nil {
+		log.Error().
+			Caller().
+			Str("func", "RenameNode").
+			Str("node", node.Hostname).
+			Str("newName", newName).
+			Err(err).
+			Msg("failed to rename node")
+
+		return err
+	}
+	node.GivenName = newName
+
+	if err := hsdb.db.Model(node).Updates(types.Node{
+		GivenName: newName,
+	}).Error; err != nil {
+		return fmt.Errorf("failed to rename node in the database: %w", err)
+	}
+
+	hsdb.notifier.NotifyWithIgnore(types.StateUpdate{
+		Type:    types.StatePeerChanged,
+		Changed: types.Nodes{node},
+	}, node.MachineKey)
+
+	return nil
+}
+
+// NodeSetExpiry takes a Node struct and  a new expiry time.
+func (hsdb *HSDatabase) NodeSetExpiry(node *types.Node, expiry time.Time) error {
+	hsdb.mu.Lock()
+	defer hsdb.mu.Unlock()
+
+	return hsdb.nodeSetExpiry(node, expiry)
+}
+
+func (hsdb *HSDatabase) nodeSetExpiry(node *types.Node, expiry time.Time) error {
+	if err := hsdb.db.Model(node).Updates(types.Node{
+		Expiry: &expiry,
+	}).Error; err != nil {
+		return fmt.Errorf(
+			"failed to refresh node (update expiration) in the database: %w",
+			err,
+		)
+	}
+
+	hsdb.notifier.NotifyWithIgnore(types.StateUpdate{
+		Type:    types.StatePeerChanged,
+		Changed: types.Nodes{node},
+	}, node.MachineKey)
+
+	return nil
+}
+
+// DeleteNode deletes a Node from the database.
+func (hsdb *HSDatabase) DeleteNode(node *types.Node) error {
+	hsdb.mu.Lock()
+	defer hsdb.mu.Unlock()
+
+	return hsdb.deleteNode(node)
+}
+
+func (hsdb *HSDatabase) deleteNode(node *types.Node) error {
+	err := hsdb.deleteNodeRoutes(node)
+	if err != nil {
+		return err
+	}
+
+	// Unscoped causes the node to be fully removed from the database.
+	if err := hsdb.db.Unscoped().Delete(&node).Error; err != nil {
+		return err
+	}
+
+	hsdb.notifier.NotifyAll(types.StateUpdate{
+		Type:    types.StatePeerRemoved,
+		Removed: []tailcfg.NodeID{tailcfg.NodeID(node.ID)},
+	})
+
+	return nil
+}
+
+// UpdateLastSeen sets a node's last seen field indicating that we
+// have recently communicating with this node.
+// This is mostly used to indicate if a node is online and is not
+// extremely important to make sure is fully correct and to avoid
+// holding up the hot path, does not contain any locks and isnt
+// concurrency safe. But that should be ok.
+func (hsdb *HSDatabase) UpdateLastSeen(node *types.Node) error {
+	return hsdb.db.Model(node).Updates(types.Node{
+		LastSeen: node.LastSeen,
+	}).Error
+}
+
+func (hsdb *HSDatabase) RegisterNodeFromAuthCallback(
+	cache *cache.Cache,
+	nodeKeyStr string,
+	userName string,
+	nodeExpiry *time.Time,
+	registrationMethod string,
+) (*types.Node, error) {
+	hsdb.mu.Lock()
+	defer hsdb.mu.Unlock()
+
+	nodeKey := key.NodePublic{}
+	err := nodeKey.UnmarshalText([]byte(nodeKeyStr))
+	if err != nil {
+		return nil, err
+	}
+
+	log.Debug().
+		Str("nodeKey", nodeKey.ShortString()).
+		Str("userName", userName).
+		Str("registrationMethod", registrationMethod).
+		Str("expiresAt", fmt.Sprintf("%v", nodeExpiry)).
+		Msg("Registering node from API/CLI or auth callback")
+
+	if nodeInterface, ok := cache.Get(util.NodePublicKeyStripPrefix(nodeKey)); ok {
+		if registrationNode, ok := nodeInterface.(types.Node); ok {
+			user, err := hsdb.getUser(userName)
+			if err != nil {
+				return nil, fmt.Errorf(
+					"failed to find user in register node from auth callback, %w",
+					err,
+				)
+			}
+
+			// Registration of expired node with different user
+			if registrationNode.ID != 0 &&
+				registrationNode.UserID != user.ID {
+				return nil, ErrDifferentRegisteredUser
+			}
+
+			registrationNode.UserID = user.ID
+			registrationNode.RegisterMethod = registrationMethod
+
+			if nodeExpiry != nil {
+				registrationNode.Expiry = nodeExpiry
+			}
+
+			node, err := hsdb.registerNode(
+				registrationNode,
+			)
+
+			if err == nil {
+				cache.Delete(nodeKeyStr)
+			}
+
+			return node, err
+		} else {
+			return nil, ErrCouldNotConvertNodeInterface
+		}
+	}
+
+	return nil, ErrNodeNotFoundRegistrationCache
+}
+
+// RegisterNode is executed from the CLI to register a new Node using its MachineKey.
+func (hsdb *HSDatabase) RegisterNode(node types.Node) (*types.Node, error) {
+	hsdb.mu.Lock()
+	defer hsdb.mu.Unlock()
+
+	return hsdb.registerNode(node)
+}
+
+func (hsdb *HSDatabase) registerNode(node types.Node) (*types.Node, error) {
+	log.Debug().
+		Str("node", node.Hostname).
+		Str("machine_key", node.MachineKey).
+		Str("node_key", node.NodeKey).
+		Str("user", node.User.Name).
+		Msg("Registering node")
+
+	// If the node exists and we had already IPs for it, we just save it
+	// so we store the node.Expire and node.Nodekey that has been set when
+	// adding it to the registrationCache
+	if len(node.IPAddresses) > 0 {
+		if err := hsdb.db.Save(&node).Error; err != nil {
+			return nil, fmt.Errorf("failed register existing node in the database: %w", err)
+		}
+
+		log.Trace().
+			Caller().
+			Str("node", node.Hostname).
+			Str("machine_key", node.MachineKey).
+			Str("node_key", node.NodeKey).
+			Str("user", node.User.Name).
+			Msg("Node authorized again")
+
+		return &node, nil
+	}
+
+	hsdb.ipAllocationMutex.Lock()
+	defer hsdb.ipAllocationMutex.Unlock()
+
+	ips, err := hsdb.getAvailableIPs()
+	if err != nil {
+		log.Error().
+			Caller().
+			Err(err).
+			Str("node", node.Hostname).
+			Msg("Could not find IP for the new node")
+
+		return nil, err
+	}
+
+	node.IPAddresses = ips
+
+	if err := hsdb.db.Save(&node).Error; err != nil {
+		return nil, fmt.Errorf("failed register(save) node in the database: %w", err)
+	}
+
+	log.Trace().
+		Caller().
+		Str("node", node.Hostname).
+		Str("ip", strings.Join(ips.StringSlice(), ",")).
+		Msg("Node registered with the database")
+
+	return &node, nil
+}
+
+// NodeSetNodeKey sets the node key of a node and saves it to the database.
+func (hsdb *HSDatabase) NodeSetNodeKey(node *types.Node, nodeKey key.NodePublic) error {
+	hsdb.mu.Lock()
+	defer hsdb.mu.Unlock()
+
+	if err := hsdb.db.Model(node).Updates(types.Node{
+		NodeKey: util.NodePublicKeyStripPrefix(nodeKey),
+	}).Error; err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// NodeSetMachineKey sets the node key of a node and saves it to the database.
+func (hsdb *HSDatabase) NodeSetMachineKey(
+	node *types.Node,
+	machineKey key.MachinePublic,
+) error {
+	hsdb.mu.Lock()
+	defer hsdb.mu.Unlock()
+
+	if err := hsdb.db.Model(node).Updates(types.Node{
+		MachineKey: util.MachinePublicKeyStripPrefix(machineKey),
+	}).Error; err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// NodeSave saves a node object to the database, prefer to use a specific save method rather
+// than this. It is intended to be used when we are changing or.
+func (hsdb *HSDatabase) NodeSave(node *types.Node) error {
+	hsdb.mu.Lock()
+	defer hsdb.mu.Unlock()
+
+	if err := hsdb.db.Save(node).Error; err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// GetAdvertisedRoutes returns the routes that are be advertised by the given node.
+func (hsdb *HSDatabase) GetAdvertisedRoutes(node *types.Node) ([]netip.Prefix, error) {
+	hsdb.mu.RLock()
+	defer hsdb.mu.RUnlock()
+
+	return hsdb.getAdvertisedRoutes(node)
+}
+
+func (hsdb *HSDatabase) getAdvertisedRoutes(node *types.Node) ([]netip.Prefix, error) {
+	routes := types.Routes{}
+
+	err := hsdb.db.
+		Preload("Node").
+		Where("node_id = ? AND advertised = ?", node.ID, true).Find(&routes).Error
+	if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
+		log.Error().
+			Caller().
+			Err(err).
+			Str("node", node.Hostname).
+			Msg("Could not get advertised routes for node")
+
+		return nil, err
+	}
+
+	prefixes := []netip.Prefix{}
+	for _, route := range routes {
+		prefixes = append(prefixes, netip.Prefix(route.Prefix))
+	}
+
+	return prefixes, nil
+}
+
+// GetEnabledRoutes returns the routes that are enabled for the node.
+func (hsdb *HSDatabase) GetEnabledRoutes(node *types.Node) ([]netip.Prefix, error) {
+	hsdb.mu.RLock()
+	defer hsdb.mu.RUnlock()
+
+	return hsdb.getEnabledRoutes(node)
+}
+
+func (hsdb *HSDatabase) getEnabledRoutes(node *types.Node) ([]netip.Prefix, error) {
+	routes := types.Routes{}
+
+	err := hsdb.db.
+		Preload("Node").
+		Where("node_id = ? AND advertised = ? AND enabled = ?", node.ID, true, true).
+		Find(&routes).Error
+	if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
+		log.Error().
+			Caller().
+			Err(err).
+			Str("node", node.Hostname).
+			Msg("Could not get enabled routes for node")
+
+		return nil, err
+	}
+
+	prefixes := []netip.Prefix{}
+	for _, route := range routes {
+		prefixes = append(prefixes, netip.Prefix(route.Prefix))
+	}
+
+	return prefixes, nil
+}
+
+func (hsdb *HSDatabase) IsRoutesEnabled(node *types.Node, routeStr string) bool {
+	hsdb.mu.RLock()
+	defer hsdb.mu.RUnlock()
+
+	route, err := netip.ParsePrefix(routeStr)
+	if err != nil {
+		return false
+	}
+
+	enabledRoutes, err := hsdb.getEnabledRoutes(node)
+	if err != nil {
+		log.Error().Err(err).Msg("Could not get enabled routes")
+
+		return false
+	}
+
+	for _, enabledRoute := range enabledRoutes {
+		if route == enabledRoute {
+			return true
+		}
+	}
+
+	return false
+}
+
+func OnlineNodeMap(peers types.Nodes) map[tailcfg.NodeID]bool {
+	ret := make(map[tailcfg.NodeID]bool)
+
+	for _, peer := range peers {
+		ret[tailcfg.NodeID(peer.ID)] = peer.IsOnline()
+	}
+
+	return ret
+}
+
+func (hsdb *HSDatabase) ListOnlineNodes(
+	node *types.Node,
+) (map[tailcfg.NodeID]bool, error) {
+	hsdb.mu.RLock()
+	defer hsdb.mu.RUnlock()
+
+	peers, err := hsdb.listPeers(node)
+	if err != nil {
+		return nil, err
+	}
+
+	return OnlineNodeMap(peers), nil
+}
+
+// enableRoutes enables new routes based on a list of new routes.
+func (hsdb *HSDatabase) enableRoutes(node *types.Node, routeStrs ...string) error {
+	newRoutes := make([]netip.Prefix, len(routeStrs))
+	for index, routeStr := range routeStrs {
+		route, err := netip.ParsePrefix(routeStr)
+		if err != nil {
+			return err
+		}
+
+		newRoutes[index] = route
+	}
+
+	advertisedRoutes, err := hsdb.getAdvertisedRoutes(node)
+	if err != nil {
+		return err
+	}
+
+	for _, newRoute := range newRoutes {
+		if !util.StringOrPrefixListContains(advertisedRoutes, newRoute) {
+			return fmt.Errorf(
+				"route (%s) is not available on node %s: %w",
+				node.Hostname,
+				newRoute, ErrNodeRouteIsNotAvailable,
+			)
+		}
+	}
+
+	// Separate loop so we don't leave things in a half-updated state
+	for _, prefix := range newRoutes {
+		route := types.Route{}
+		err := hsdb.db.Preload("Node").
+			Where("node_id = ? AND prefix = ?", node.ID, types.IPPrefix(prefix)).
+			First(&route).Error
+		if err == nil {
+			route.Enabled = true
+
+			// Mark already as primary if there is only this node offering this subnet
+			// (and is not an exit route)
+			if !route.IsExitRoute() {
+				route.IsPrimary = hsdb.isUniquePrefix(route)
+			}
+
+			err = hsdb.db.Save(&route).Error
+			if err != nil {
+				return fmt.Errorf("failed to enable route: %w", err)
+			}
+		} else {
+			return fmt.Errorf("failed to find route: %w", err)
+		}
+	}
+
+	hsdb.notifier.NotifyWithIgnore(types.StateUpdate{
+		Type:    types.StatePeerChanged,
+		Changed: types.Nodes{node},
+	}, node.MachineKey)
+
+	return nil
+}
+
+func generateGivenName(suppliedName string, randomSuffix bool) (string, error) {
+	normalizedHostname, err := util.NormalizeToFQDNRulesConfigFromViper(
+		suppliedName,
+	)
+	if err != nil {
+		return "", err
+	}
+
+	if randomSuffix {
+		// Trim if a hostname will be longer than 63 chars after adding the hash.
+		trimmedHostnameLength := util.LabelHostnameLength - NodeGivenNameHashLength - NodeGivenNameTrimSize
+		if len(normalizedHostname) > trimmedHostnameLength {
+			normalizedHostname = normalizedHostname[:trimmedHostnameLength]
+		}
+
+		suffix, err := util.GenerateRandomStringDNSSafe(NodeGivenNameHashLength)
+		if err != nil {
+			return "", err
+		}
+
+		normalizedHostname += "-" + suffix
+	}
+
+	return normalizedHostname, nil
+}
+
+func (hsdb *HSDatabase) GenerateGivenName(machineKey string, suppliedName string) (string, error) {
+	hsdb.mu.RLock()
+	defer hsdb.mu.RUnlock()
+
+	givenName, err := generateGivenName(suppliedName, false)
+	if err != nil {
+		return "", err
+	}
+
+	// Tailscale rules (may differ) https://tailscale.com/kb/1098/machine-names/
+	nodes, err := hsdb.listNodesByGivenName(givenName)
+	if err != nil {
+		return "", err
+	}
+
+	for _, node := range nodes {
+		if node.MachineKey != machineKey && node.GivenName == givenName {
+			postfixedName, err := generateGivenName(suppliedName, true)
+			if err != nil {
+				return "", err
+			}
+
+			givenName = postfixedName
+		}
+	}
+
+	return givenName, nil
+}
+
+func (hsdb *HSDatabase) ExpireEphemeralNodes(inactivityThreshhold time.Duration) {
+	hsdb.mu.Lock()
+	defer hsdb.mu.Unlock()
+
+	users, err := hsdb.listUsers()
+	if err != nil {
+		log.Error().Err(err).Msg("Error listing users")
+
+		return
+	}
+
+	for _, user := range users {
+		nodes, err := hsdb.listNodesByUser(user.Name)
+		if err != nil {
+			log.Error().
+				Err(err).
+				Str("user", user.Name).
+				Msg("Error listing nodes in user")
+
+			return
+		}
+
+		expired := make([]tailcfg.NodeID, 0)
+		for idx, node := range nodes {
+			if node.IsEphemeral() && node.LastSeen != nil &&
+				time.Now().
+					After(node.LastSeen.Add(inactivityThreshhold)) {
+				expired = append(expired, tailcfg.NodeID(node.ID))
+
+				log.Info().
+					Str("node", node.Hostname).
+					Msg("Ephemeral client removed from database")
+
+				err = hsdb.deleteNode(nodes[idx])
+				if err != nil {
+					log.Error().
+						Err(err).
+						Str("node", node.Hostname).
+						Msg("🤮 Cannot delete ephemeral node from the database")
+				}
+			}
+		}
+
+		if len(expired) > 0 {
+			hsdb.notifier.NotifyAll(types.StateUpdate{
+				Type:    types.StatePeerRemoved,
+				Removed: expired,
+			})
+		}
+	}
+}
+
+func (hsdb *HSDatabase) ExpireExpiredNodes(lastCheck time.Time) time.Time {
+	hsdb.mu.Lock()
+	defer hsdb.mu.Unlock()
+
+	// use the time of the start of the function to ensure we
+	// dont miss some nodes by returning it _after_ we have
+	// checked everything.
+	started := time.Now()
+
+	users, err := hsdb.listUsers()
+	if err != nil {
+		log.Error().Err(err).Msg("Error listing users")
+
+		return time.Unix(0, 0)
+	}
+
+	for _, user := range users {
+		nodes, err := hsdb.listNodesByUser(user.Name)
+		if err != nil {
+			log.Error().
+				Err(err).
+				Str("user", user.Name).
+				Msg("Error listing nodes in user")
+
+			return time.Unix(0, 0)
+		}
+
+		expired := make([]tailcfg.NodeID, 0)
+		for index, node := range nodes {
+			if node.IsExpired() &&
+				node.Expiry.After(lastCheck) {
+				expired = append(expired, tailcfg.NodeID(node.ID))
+
+				now := time.Now()
+				err := hsdb.nodeSetExpiry(nodes[index], now)
+				if err != nil {
+					log.Error().
+						Err(err).
+						Str("node", node.Hostname).
+						Str("name", node.GivenName).
+						Msg("🤮 Cannot expire node")
+				} else {
+					log.Info().
+						Str("node", node.Hostname).
+						Str("name", node.GivenName).
+						Msg("Node successfully expired")
+				}
+			}
+		}
+
+		if len(expired) > 0 {
+			hsdb.notifier.NotifyAll(types.StateUpdate{
+				Type:    types.StatePeerRemoved,
+				Removed: expired,
+			})
+		}
+	}
+
+	return started
+}
diff --git a/hscontrol/db/machine_test.go b/hscontrol/db/node_test.go
similarity index 65%
rename from hscontrol/db/machine_test.go
rename to hscontrol/db/node_test.go
index 0115ee901e..54b1cd07b2 100644
--- a/hscontrol/db/machine_test.go
+++ b/hscontrol/db/node_test.go
@@ -15,95 +15,95 @@ import (
 	"tailscale.com/types/key"
 )
 
-func (s *Suite) TestGetMachine(c *check.C) {
+func (s *Suite) TestGetNode(c *check.C) {
 	user, err := db.CreateUser("test")
 	c.Assert(err, check.IsNil)
 
 	pak, err := db.CreatePreAuthKey(user.Name, false, false, nil, nil)
 	c.Assert(err, check.IsNil)
 
-	_, err = db.GetMachine("test", "testmachine")
+	_, err = db.GetNode("test", "testnode")
 	c.Assert(err, check.NotNil)
 
-	machine := &types.Machine{
+	node := &types.Node{
 		ID:             0,
 		MachineKey:     "foo",
 		NodeKey:        "bar",
 		DiscoKey:       "faa",
-		Hostname:       "testmachine",
+		Hostname:       "testnode",
 		UserID:         user.ID,
 		RegisterMethod: util.RegisterMethodAuthKey,
 		AuthKeyID:      uint(pak.ID),
 	}
-	db.db.Save(machine)
+	db.db.Save(node)
 
-	_, err = db.GetMachine("test", "testmachine")
+	_, err = db.GetNode("test", "testnode")
 	c.Assert(err, check.IsNil)
 }
 
-func (s *Suite) TestGetMachineByID(c *check.C) {
+func (s *Suite) TestGetNodeByID(c *check.C) {
 	user, err := db.CreateUser("test")
 	c.Assert(err, check.IsNil)
 
 	pak, err := db.CreatePreAuthKey(user.Name, false, false, nil, nil)
 	c.Assert(err, check.IsNil)
 
-	_, err = db.GetMachineByID(0)
+	_, err = db.GetNodeByID(0)
 	c.Assert(err, check.NotNil)
 
-	machine := types.Machine{
+	node := types.Node{
 		ID:             0,
 		MachineKey:     "foo",
 		NodeKey:        "bar",
 		DiscoKey:       "faa",
-		Hostname:       "testmachine",
+		Hostname:       "testnode",
 		UserID:         user.ID,
 		RegisterMethod: util.RegisterMethodAuthKey,
 		AuthKeyID:      uint(pak.ID),
 	}
-	db.db.Save(&machine)
+	db.db.Save(&node)
 
-	_, err = db.GetMachineByID(0)
+	_, err = db.GetNodeByID(0)
 	c.Assert(err, check.IsNil)
 }
 
-func (s *Suite) TestGetMachineByNodeKey(c *check.C) {
+func (s *Suite) TestGetNodeByNodeKey(c *check.C) {
 	user, err := db.CreateUser("test")
 	c.Assert(err, check.IsNil)
 
 	pak, err := db.CreatePreAuthKey(user.Name, false, false, nil, nil)
 	c.Assert(err, check.IsNil)
 
-	_, err = db.GetMachineByID(0)
+	_, err = db.GetNodeByID(0)
 	c.Assert(err, check.NotNil)
 
 	nodeKey := key.NewNode()
 	machineKey := key.NewMachine()
 
-	machine := types.Machine{
+	node := types.Node{
 		ID:             0,
 		MachineKey:     util.MachinePublicKeyStripPrefix(machineKey.Public()),
 		NodeKey:        util.NodePublicKeyStripPrefix(nodeKey.Public()),
 		DiscoKey:       "faa",
-		Hostname:       "testmachine",
+		Hostname:       "testnode",
 		UserID:         user.ID,
 		RegisterMethod: util.RegisterMethodAuthKey,
 		AuthKeyID:      uint(pak.ID),
 	}
-	db.db.Save(&machine)
+	db.db.Save(&node)
 
-	_, err = db.GetMachineByNodeKey(nodeKey.Public())
+	_, err = db.GetNodeByNodeKey(nodeKey.Public())
 	c.Assert(err, check.IsNil)
 }
 
-func (s *Suite) TestGetMachineByAnyNodeKey(c *check.C) {
+func (s *Suite) TestGetNodeByAnyNodeKey(c *check.C) {
 	user, err := db.CreateUser("test")
 	c.Assert(err, check.IsNil)
 
 	pak, err := db.CreatePreAuthKey(user.Name, false, false, nil, nil)
 	c.Assert(err, check.IsNil)
 
-	_, err = db.GetMachineByID(0)
+	_, err = db.GetNodeByID(0)
 	c.Assert(err, check.NotNil)
 
 	nodeKey := key.NewNode()
@@ -111,41 +111,41 @@ func (s *Suite) TestGetMachineByAnyNodeKey(c *check.C) {
 
 	machineKey := key.NewMachine()
 
-	machine := types.Machine{
+	node := types.Node{
 		ID:             0,
 		MachineKey:     util.MachinePublicKeyStripPrefix(machineKey.Public()),
 		NodeKey:        util.NodePublicKeyStripPrefix(nodeKey.Public()),
 		DiscoKey:       "faa",
-		Hostname:       "testmachine",
+		Hostname:       "testnode",
 		UserID:         user.ID,
 		RegisterMethod: util.RegisterMethodAuthKey,
 		AuthKeyID:      uint(pak.ID),
 	}
-	db.db.Save(&machine)
+	db.db.Save(&node)
 
-	_, err = db.GetMachineByAnyKey(machineKey.Public(), nodeKey.Public(), oldNodeKey.Public())
+	_, err = db.GetNodeByAnyKey(machineKey.Public(), nodeKey.Public(), oldNodeKey.Public())
 	c.Assert(err, check.IsNil)
 }
 
-func (s *Suite) TestHardDeleteMachine(c *check.C) {
+func (s *Suite) TestHardDeleteNode(c *check.C) {
 	user, err := db.CreateUser("test")
 	c.Assert(err, check.IsNil)
-	machine := types.Machine{
+	node := types.Node{
 		ID:             0,
 		MachineKey:     "foo",
 		NodeKey:        "bar",
 		DiscoKey:       "faa",
-		Hostname:       "testmachine3",
+		Hostname:       "testnode3",
 		UserID:         user.ID,
 		RegisterMethod: util.RegisterMethodAuthKey,
 		AuthKeyID:      uint(1),
 	}
-	db.db.Save(&machine)
+	db.db.Save(&node)
 
-	err = db.DeleteMachine(&machine)
+	err = db.DeleteNode(&node)
 	c.Assert(err, check.IsNil)
 
-	_, err = db.GetMachine(user.Name, "testmachine3")
+	_, err = db.GetNode(user.Name, "testnode3")
 	c.Assert(err, check.NotNil)
 }
 
@@ -156,33 +156,33 @@ func (s *Suite) TestListPeers(c *check.C) {
 	pak, err := db.CreatePreAuthKey(user.Name, false, false, nil, nil)
 	c.Assert(err, check.IsNil)
 
-	_, err = db.GetMachineByID(0)
+	_, err = db.GetNodeByID(0)
 	c.Assert(err, check.NotNil)
 
 	for index := 0; index <= 10; index++ {
-		machine := types.Machine{
+		node := types.Node{
 			ID:             uint64(index),
 			MachineKey:     "foo" + strconv.Itoa(index),
 			NodeKey:        "bar" + strconv.Itoa(index),
 			DiscoKey:       "faa" + strconv.Itoa(index),
-			Hostname:       "testmachine" + strconv.Itoa(index),
+			Hostname:       "testnode" + strconv.Itoa(index),
 			UserID:         user.ID,
 			RegisterMethod: util.RegisterMethodAuthKey,
 			AuthKeyID:      uint(pak.ID),
 		}
-		db.db.Save(&machine)
+		db.db.Save(&node)
 	}
 
-	machine0ByID, err := db.GetMachineByID(0)
+	node0ByID, err := db.GetNodeByID(0)
 	c.Assert(err, check.IsNil)
 
-	peersOfMachine0, err := db.ListPeers(machine0ByID)
+	peersOfNode0, err := db.ListPeers(node0ByID)
 	c.Assert(err, check.IsNil)
 
-	c.Assert(len(peersOfMachine0), check.Equals, 9)
-	c.Assert(peersOfMachine0[0].Hostname, check.Equals, "testmachine2")
-	c.Assert(peersOfMachine0[5].Hostname, check.Equals, "testmachine7")
-	c.Assert(peersOfMachine0[8].Hostname, check.Equals, "testmachine10")
+	c.Assert(len(peersOfNode0), check.Equals, 9)
+	c.Assert(peersOfNode0[0].Hostname, check.Equals, "testnode2")
+	c.Assert(peersOfNode0[5].Hostname, check.Equals, "testnode7")
+	c.Assert(peersOfNode0[8].Hostname, check.Equals, "testnode10")
 }
 
 func (s *Suite) TestGetACLFilteredPeers(c *check.C) {
@@ -201,24 +201,24 @@ func (s *Suite) TestGetACLFilteredPeers(c *check.C) {
 		stor = append(stor, base{user, pak})
 	}
 
-	_, err := db.GetMachineByID(0)
+	_, err := db.GetNodeByID(0)
 	c.Assert(err, check.NotNil)
 
 	for index := 0; index <= 10; index++ {
-		machine := types.Machine{
+		node := types.Node{
 			ID:         uint64(index),
 			MachineKey: "foo" + strconv.Itoa(index),
 			NodeKey:    "bar" + strconv.Itoa(index),
 			DiscoKey:   "faa" + strconv.Itoa(index),
-			IPAddresses: types.MachineAddresses{
+			IPAddresses: types.NodeAddresses{
 				netip.MustParseAddr(fmt.Sprintf("100.64.0.%v", strconv.Itoa(index+1))),
 			},
-			Hostname:       "testmachine" + strconv.Itoa(index),
+			Hostname:       "testnode" + strconv.Itoa(index),
 			UserID:         stor[index%2].user.ID,
 			RegisterMethod: util.RegisterMethodAuthKey,
 			AuthKeyID:      uint(stor[index%2].key.ID),
 		}
-		db.db.Save(&machine)
+		db.db.Save(&node)
 	}
 
 	aclPolicy := &policy.ACLPolicy{
@@ -242,80 +242,80 @@ func (s *Suite) TestGetACLFilteredPeers(c *check.C) {
 		Tests: []policy.ACLTest{},
 	}
 
-	adminMachine, err := db.GetMachineByID(1)
-	c.Logf("Machine(%v), user: %v", adminMachine.Hostname, adminMachine.User)
+	adminNode, err := db.GetNodeByID(1)
+	c.Logf("Node(%v), user: %v", adminNode.Hostname, adminNode.User)
 	c.Assert(err, check.IsNil)
 
-	testMachine, err := db.GetMachineByID(2)
-	c.Logf("Machine(%v), user: %v", testMachine.Hostname, testMachine.User)
+	testNode, err := db.GetNodeByID(2)
+	c.Logf("Node(%v), user: %v", testNode.Hostname, testNode.User)
 	c.Assert(err, check.IsNil)
 
-	adminPeers, err := db.ListPeers(adminMachine)
+	adminPeers, err := db.ListPeers(adminNode)
 	c.Assert(err, check.IsNil)
 
-	testPeers, err := db.ListPeers(testMachine)
+	testPeers, err := db.ListPeers(testNode)
 	c.Assert(err, check.IsNil)
 
-	adminRules, _, err := policy.GenerateFilterAndSSHRules(aclPolicy, adminMachine, adminPeers)
+	adminRules, _, err := policy.GenerateFilterAndSSHRules(aclPolicy, adminNode, adminPeers)
 	c.Assert(err, check.IsNil)
 
-	testRules, _, err := policy.GenerateFilterAndSSHRules(aclPolicy, testMachine, testPeers)
+	testRules, _, err := policy.GenerateFilterAndSSHRules(aclPolicy, testNode, testPeers)
 	c.Assert(err, check.IsNil)
 
-	peersOfAdminMachine := policy.FilterMachinesByACL(adminMachine, adminPeers, adminRules)
-	peersOfTestMachine := policy.FilterMachinesByACL(testMachine, testPeers, testRules)
+	peersOfAdminNode := policy.FilterNodesByACL(adminNode, adminPeers, adminRules)
+	peersOfTestNode := policy.FilterNodesByACL(testNode, testPeers, testRules)
 
-	c.Log(peersOfTestMachine)
-	c.Assert(len(peersOfTestMachine), check.Equals, 9)
-	c.Assert(peersOfTestMachine[0].Hostname, check.Equals, "testmachine1")
-	c.Assert(peersOfTestMachine[1].Hostname, check.Equals, "testmachine3")
-	c.Assert(peersOfTestMachine[3].Hostname, check.Equals, "testmachine5")
+	c.Log(peersOfTestNode)
+	c.Assert(len(peersOfTestNode), check.Equals, 9)
+	c.Assert(peersOfTestNode[0].Hostname, check.Equals, "testnode1")
+	c.Assert(peersOfTestNode[1].Hostname, check.Equals, "testnode3")
+	c.Assert(peersOfTestNode[3].Hostname, check.Equals, "testnode5")
 
-	c.Log(peersOfAdminMachine)
-	c.Assert(len(peersOfAdminMachine), check.Equals, 9)
-	c.Assert(peersOfAdminMachine[0].Hostname, check.Equals, "testmachine2")
-	c.Assert(peersOfAdminMachine[2].Hostname, check.Equals, "testmachine4")
-	c.Assert(peersOfAdminMachine[5].Hostname, check.Equals, "testmachine7")
+	c.Log(peersOfAdminNode)
+	c.Assert(len(peersOfAdminNode), check.Equals, 9)
+	c.Assert(peersOfAdminNode[0].Hostname, check.Equals, "testnode2")
+	c.Assert(peersOfAdminNode[2].Hostname, check.Equals, "testnode4")
+	c.Assert(peersOfAdminNode[5].Hostname, check.Equals, "testnode7")
 }
 
-func (s *Suite) TestExpireMachine(c *check.C) {
+func (s *Suite) TestExpireNode(c *check.C) {
 	user, err := db.CreateUser("test")
 	c.Assert(err, check.IsNil)
 
 	pak, err := db.CreatePreAuthKey(user.Name, false, false, nil, nil)
 	c.Assert(err, check.IsNil)
 
-	_, err = db.GetMachine("test", "testmachine")
+	_, err = db.GetNode("test", "testnode")
 	c.Assert(err, check.NotNil)
 
-	machine := &types.Machine{
+	node := &types.Node{
 		ID:             0,
 		MachineKey:     "foo",
 		NodeKey:        "bar",
 		DiscoKey:       "faa",
-		Hostname:       "testmachine",
+		Hostname:       "testnode",
 		UserID:         user.ID,
 		RegisterMethod: util.RegisterMethodAuthKey,
 		AuthKeyID:      uint(pak.ID),
 		Expiry:         &time.Time{},
 	}
-	db.db.Save(machine)
+	db.db.Save(node)
 
-	machineFromDB, err := db.GetMachine("test", "testmachine")
+	nodeFromDB, err := db.GetNode("test", "testnode")
 	c.Assert(err, check.IsNil)
-	c.Assert(machineFromDB, check.NotNil)
+	c.Assert(nodeFromDB, check.NotNil)
 
-	c.Assert(machineFromDB.IsExpired(), check.Equals, false)
+	c.Assert(nodeFromDB.IsExpired(), check.Equals, false)
 
 	now := time.Now()
-	err = db.MachineSetExpiry(machineFromDB, now)
+	err = db.NodeSetExpiry(nodeFromDB, now)
 	c.Assert(err, check.IsNil)
 
-	c.Assert(machineFromDB.IsExpired(), check.Equals, true)
+	c.Assert(nodeFromDB.IsExpired(), check.Equals, true)
 }
 
 func (s *Suite) TestSerdeAddressStrignSlice(c *check.C) {
-	input := types.MachineAddresses([]netip.Addr{
+	input := types.NodeAddresses([]netip.Addr{
 		netip.MustParseAddr("192.0.2.1"),
 		netip.MustParseAddr("2001:db8::1"),
 	})
@@ -325,7 +325,7 @@ func (s *Suite) TestSerdeAddressStrignSlice(c *check.C) {
 		c.Assert(serial, check.Equals, "192.0.2.1,2001:db8::1")
 	}
 
-	var deserialized types.MachineAddresses
+	var deserialized types.NodeAddresses
 	err = deserialized.Scan(serialized)
 	c.Assert(err, check.IsNil)
 
@@ -342,12 +342,12 @@ func (s *Suite) TestGenerateGivenName(c *check.C) {
 	pak, err := db.CreatePreAuthKey(user1.Name, false, false, nil, nil)
 	c.Assert(err, check.IsNil)
 
-	_, err = db.GetMachine("user-1", "testmachine")
+	_, err = db.GetNode("user-1", "testnode")
 	c.Assert(err, check.NotNil)
 
-	machine := &types.Machine{
+	node := &types.Node{
 		ID:             0,
-		MachineKey:     "machine-key-1",
+		MachineKey:     "node-key-1",
 		NodeKey:        "node-key-1",
 		DiscoKey:       "disco-key-1",
 		Hostname:       "hostname-1",
@@ -356,27 +356,27 @@ func (s *Suite) TestGenerateGivenName(c *check.C) {
 		RegisterMethod: util.RegisterMethodAuthKey,
 		AuthKeyID:      uint(pak.ID),
 	}
-	db.db.Save(machine)
+	db.db.Save(node)
 
-	givenName, err := db.GenerateGivenName("machine-key-2", "hostname-2")
-	comment := check.Commentf("Same user, unique machines, unique hostnames, no conflict")
+	givenName, err := db.GenerateGivenName("node-key-2", "hostname-2")
+	comment := check.Commentf("Same user, unique nodes, unique hostnames, no conflict")
 	c.Assert(err, check.IsNil, comment)
 	c.Assert(givenName, check.Equals, "hostname-2", comment)
 
-	givenName, err = db.GenerateGivenName("machine-key-1", "hostname-1")
-	comment = check.Commentf("Same user, same machine, same hostname, no conflict")
+	givenName, err = db.GenerateGivenName("node-key-1", "hostname-1")
+	comment = check.Commentf("Same user, same node, same hostname, no conflict")
 	c.Assert(err, check.IsNil, comment)
 	c.Assert(givenName, check.Equals, "hostname-1", comment)
 
-	givenName, err = db.GenerateGivenName("machine-key-2", "hostname-1")
-	comment = check.Commentf("Same user, unique machines, same hostname, conflict")
+	givenName, err = db.GenerateGivenName("node-key-2", "hostname-1")
+	comment = check.Commentf("Same user, unique nodes, same hostname, conflict")
 	c.Assert(err, check.IsNil, comment)
-	c.Assert(givenName, check.Matches, fmt.Sprintf("^hostname-1-[a-z0-9]{%d}$", MachineGivenNameHashLength), comment)
+	c.Assert(givenName, check.Matches, fmt.Sprintf("^hostname-1-[a-z0-9]{%d}$", NodeGivenNameHashLength), comment)
 
-	givenName, err = db.GenerateGivenName("machine-key-2", "hostname-1")
-	comment = check.Commentf("Unique users, unique machines, same hostname, conflict")
+	givenName, err = db.GenerateGivenName("node-key-2", "hostname-1")
+	comment = check.Commentf("Unique users, unique nodes, same hostname, conflict")
 	c.Assert(err, check.IsNil, comment)
-	c.Assert(givenName, check.Matches, fmt.Sprintf("^hostname-1-[a-z0-9]{%d}$", MachineGivenNameHashLength), comment)
+	c.Assert(givenName, check.Matches, fmt.Sprintf("^hostname-1-[a-z0-9]{%d}$", NodeGivenNameHashLength), comment)
 }
 
 func (s *Suite) TestSetTags(c *check.C) {
@@ -386,37 +386,37 @@ func (s *Suite) TestSetTags(c *check.C) {
 	pak, err := db.CreatePreAuthKey(user.Name, false, false, nil, nil)
 	c.Assert(err, check.IsNil)
 
-	_, err = db.GetMachine("test", "testmachine")
+	_, err = db.GetNode("test", "testnode")
 	c.Assert(err, check.NotNil)
 
-	machine := &types.Machine{
+	node := &types.Node{
 		ID:             0,
 		MachineKey:     "foo",
 		NodeKey:        "bar",
 		DiscoKey:       "faa",
-		Hostname:       "testmachine",
+		Hostname:       "testnode",
 		UserID:         user.ID,
 		RegisterMethod: util.RegisterMethodAuthKey,
 		AuthKeyID:      uint(pak.ID),
 	}
-	db.db.Save(machine)
+	db.db.Save(node)
 
 	// assign simple tags
 	sTags := []string{"tag:test", "tag:foo"}
-	err = db.SetTags(machine, sTags)
+	err = db.SetTags(node, sTags)
 	c.Assert(err, check.IsNil)
-	machine, err = db.GetMachine("test", "testmachine")
+	node, err = db.GetNode("test", "testnode")
 	c.Assert(err, check.IsNil)
-	c.Assert(machine.ForcedTags, check.DeepEquals, types.StringList(sTags))
+	c.Assert(node.ForcedTags, check.DeepEquals, types.StringList(sTags))
 
 	// assign duplicat tags, expect no errors but no doubles in DB
 	eTags := []string{"tag:bar", "tag:test", "tag:unknown", "tag:test"}
-	err = db.SetTags(machine, eTags)
+	err = db.SetTags(node, eTags)
 	c.Assert(err, check.IsNil)
-	machine, err = db.GetMachine("test", "testmachine")
+	node, err = db.GetNode("test", "testnode")
 	c.Assert(err, check.IsNil)
 	c.Assert(
-		machine.ForcedTags,
+		node.ForcedTags,
 		check.DeepEquals,
 		types.StringList([]string{"tag:bar", "tag:test", "tag:unknown"}),
 	)
@@ -434,16 +434,16 @@ func TestHeadscale_generateGivenName(t *testing.T) {
 		wantErr bool
 	}{
 		{
-			name: "simple machine name generation",
+			name: "simple node name generation",
 			args: args{
-				suppliedName: "testmachine",
+				suppliedName: "testnode",
 				randomSuffix: false,
 			},
-			want:    regexp.MustCompile("^testmachine$"),
+			want:    regexp.MustCompile("^testnode$"),
 			wantErr: false,
 		},
 		{
-			name: "machine name with 53 chars",
+			name: "node name with 53 chars",
 			args: args{
 				suppliedName: "testmaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaachine",
 				randomSuffix: false,
@@ -452,48 +452,48 @@ func TestHeadscale_generateGivenName(t *testing.T) {
 			wantErr: false,
 		},
 		{
-			name: "machine name with 63 chars",
+			name: "node name with 63 chars",
 			args: args{
-				suppliedName: "machineeee12345678901234567890123456789012345678901234567890123",
+				suppliedName: "nodeeeeeee12345678901234567890123456789012345678901234567890123",
 				randomSuffix: false,
 			},
-			want:    regexp.MustCompile("^machineeee12345678901234567890123456789012345678901234567890123$"),
+			want:    regexp.MustCompile("^nodeeeeeee12345678901234567890123456789012345678901234567890123$"),
 			wantErr: false,
 		},
 		{
-			name: "machine name with 64 chars",
+			name: "node name with 64 chars",
 			args: args{
-				suppliedName: "machineeee123456789012345678901234567890123456789012345678901234",
+				suppliedName: "nodeeeeeee123456789012345678901234567890123456789012345678901234",
 				randomSuffix: false,
 			},
 			want:    nil,
 			wantErr: true,
 		},
 		{
-			name: "machine name with 73 chars",
+			name: "node name with 73 chars",
 			args: args{
-				suppliedName: "machineeee123456789012345678901234567890123456789012345678901234567890123",
+				suppliedName: "nodeeeeeee123456789012345678901234567890123456789012345678901234567890123",
 				randomSuffix: false,
 			},
 			want:    nil,
 			wantErr: true,
 		},
 		{
-			name: "machine name with random suffix",
+			name: "node name with random suffix",
 			args: args{
 				suppliedName: "test",
 				randomSuffix: true,
 			},
-			want:    regexp.MustCompile(fmt.Sprintf("^test-[a-z0-9]{%d}$", MachineGivenNameHashLength)),
+			want:    regexp.MustCompile(fmt.Sprintf("^test-[a-z0-9]{%d}$", NodeGivenNameHashLength)),
 			wantErr: false,
 		},
 		{
-			name: "machine name with 63 chars with random suffix",
+			name: "node name with 63 chars with random suffix",
 			args: args{
-				suppliedName: "machineeee12345678901234567890123456789012345678901234567890123",
+				suppliedName: "nodeeee12345678901234567890123456789012345678901234567890123",
 				randomSuffix: true,
 			},
-			want:    regexp.MustCompile(fmt.Sprintf("^machineeee1234567890123456789012345678901234567890123-[a-z0-9]{%d}$", MachineGivenNameHashLength)),
+			want:    regexp.MustCompile(fmt.Sprintf("^nodeeee1234567890123456789012345678901234567890123456-[a-z0-9]{%d}$", NodeGivenNameHashLength)),
 			wantErr: false,
 		},
 	}
@@ -572,7 +572,7 @@ func (s *Suite) TestAutoApproveRoutes(c *check.C) {
 	// Check if a subprefix of an autoapproved route is approved
 	route2 := netip.MustParsePrefix("10.11.0.0/24")
 
-	machine := types.Machine{
+	node := types.Node{
 		ID:             0,
 		MachineKey:     "foo",
 		NodeKey:        util.NodePublicKeyStripPrefix(nodeKey.Public()),
@@ -588,18 +588,18 @@ func (s *Suite) TestAutoApproveRoutes(c *check.C) {
 		IPAddresses: []netip.Addr{netip.MustParseAddr("100.64.0.1")},
 	}
 
-	db.db.Save(&machine)
+	db.db.Save(&node)
 
-	err = db.SaveMachineRoutes(&machine)
+	err = db.SaveNodeRoutes(&node)
 	c.Assert(err, check.IsNil)
 
-	machine0ByID, err := db.GetMachineByID(0)
+	node0ByID, err := db.GetNodeByID(0)
 	c.Assert(err, check.IsNil)
 
-	err = db.EnableAutoApprovedRoutes(pol, machine0ByID)
+	err = db.EnableAutoApprovedRoutes(pol, node0ByID)
 	c.Assert(err, check.IsNil)
 
-	enabledRoutes, err := db.GetEnabledRoutes(machine0ByID)
+	enabledRoutes, err := db.GetEnabledRoutes(node0ByID)
 	c.Assert(err, check.IsNil)
 	c.Assert(enabledRoutes, check.HasLen, 4)
 }
diff --git a/hscontrol/db/preauth_keys.go b/hscontrol/db/preauth_keys.go
index ec7ab232f4..e743988fd8 100644
--- a/hscontrol/db/preauth_keys.go
+++ b/hscontrol/db/preauth_keys.go
@@ -203,15 +203,15 @@ func (hsdb *HSDatabase) ValidatePreAuthKey(k string) (*types.PreAuthKey, error)
 		return &pak, nil
 	}
 
-	machines := types.Machines{}
+	nodes := types.Nodes{}
 	if err := hsdb.db.
 		Preload("AuthKey").
-		Where(&types.Machine{AuthKeyID: uint(pak.ID)}).
-		Find(&machines).Error; err != nil {
+		Where(&types.Node{AuthKeyID: uint(pak.ID)}).
+		Find(&nodes).Error; err != nil {
 		return nil, err
 	}
 
-	if len(machines) != 0 || pak.Used {
+	if len(nodes) != 0 || pak.Used {
 		return nil, ErrSingleUseAuthKeyHasBeenUsed
 	}
 
diff --git a/hscontrol/db/preauth_keys_test.go b/hscontrol/db/preauth_keys_test.go
index 247ebd206f..9bf8c89271 100644
--- a/hscontrol/db/preauth_keys_test.go
+++ b/hscontrol/db/preauth_keys_test.go
@@ -75,7 +75,7 @@ func (*Suite) TestAlreadyUsedKey(c *check.C) {
 	pak, err := db.CreatePreAuthKey(user.Name, false, false, nil, nil)
 	c.Assert(err, check.IsNil)
 
-	machine := types.Machine{
+	node := types.Node{
 		ID:             0,
 		MachineKey:     "foo",
 		NodeKey:        "bar",
@@ -85,7 +85,7 @@ func (*Suite) TestAlreadyUsedKey(c *check.C) {
 		RegisterMethod: util.RegisterMethodAuthKey,
 		AuthKeyID:      uint(pak.ID),
 	}
-	db.db.Save(&machine)
+	db.db.Save(&node)
 
 	key, err := db.ValidatePreAuthKey(pak.Key)
 	c.Assert(err, check.Equals, ErrSingleUseAuthKeyHasBeenUsed)
@@ -99,7 +99,7 @@ func (*Suite) TestReusableBeingUsedKey(c *check.C) {
 	pak, err := db.CreatePreAuthKey(user.Name, true, false, nil, nil)
 	c.Assert(err, check.IsNil)
 
-	machine := types.Machine{
+	node := types.Node{
 		ID:             1,
 		MachineKey:     "foo",
 		NodeKey:        "bar",
@@ -109,7 +109,7 @@ func (*Suite) TestReusableBeingUsedKey(c *check.C) {
 		RegisterMethod: util.RegisterMethodAuthKey,
 		AuthKeyID:      uint(pak.ID),
 	}
-	db.db.Save(&machine)
+	db.db.Save(&node)
 
 	key, err := db.ValidatePreAuthKey(pak.Key)
 	c.Assert(err, check.IsNil)
@@ -136,7 +136,7 @@ func (*Suite) TestEphemeralKey(c *check.C) {
 	c.Assert(err, check.IsNil)
 
 	now := time.Now().Add(-time.Second * 30)
-	machine := types.Machine{
+	node := types.Node{
 		ID:             0,
 		MachineKey:     "foo",
 		NodeKey:        "bar",
@@ -147,19 +147,19 @@ func (*Suite) TestEphemeralKey(c *check.C) {
 		LastSeen:       &now,
 		AuthKeyID:      uint(pak.ID),
 	}
-	db.db.Save(&machine)
+	db.db.Save(&node)
 
 	_, err = db.ValidatePreAuthKey(pak.Key)
 	// Ephemeral keys are by definition reusable
 	c.Assert(err, check.IsNil)
 
-	_, err = db.GetMachine("test7", "testest")
+	_, err = db.GetNode("test7", "testest")
 	c.Assert(err, check.IsNil)
 
-	db.ExpireEphemeralMachines(time.Second * 20)
+	db.ExpireEphemeralNodes(time.Second * 20)
 
 	// The machine record should have been deleted
-	_, err = db.GetMachine("test7", "testest")
+	_, err = db.GetNode("test7", "testest")
 	c.Assert(err, check.NotNil)
 }
 
diff --git a/hscontrol/db/routes.go b/hscontrol/db/routes.go
index 2d51d18311..d73c3afe58 100644
--- a/hscontrol/db/routes.go
+++ b/hscontrol/db/routes.go
@@ -21,7 +21,7 @@ func (hsdb *HSDatabase) GetRoutes() (types.Routes, error) {
 
 func (hsdb *HSDatabase) getRoutes() (types.Routes, error) {
 	var routes types.Routes
-	err := hsdb.db.Preload("Machine").Find(&routes).Error
+	err := hsdb.db.Preload("Node").Find(&routes).Error
 	if err != nil {
 		return nil, err
 	}
@@ -29,18 +29,18 @@ func (hsdb *HSDatabase) getRoutes() (types.Routes, error) {
 	return routes, nil
 }
 
-func (hsdb *HSDatabase) GetMachineAdvertisedRoutes(machine *types.Machine) (types.Routes, error) {
+func (hsdb *HSDatabase) GetNodeAdvertisedRoutes(node *types.Node) (types.Routes, error) {
 	hsdb.mu.RLock()
 	defer hsdb.mu.RUnlock()
 
-	return hsdb.getMachineAdvertisedRoutes(machine)
+	return hsdb.getNodeAdvertisedRoutes(node)
 }
 
-func (hsdb *HSDatabase) getMachineAdvertisedRoutes(machine *types.Machine) (types.Routes, error) {
+func (hsdb *HSDatabase) getNodeAdvertisedRoutes(node *types.Node) (types.Routes, error) {
 	var routes types.Routes
 	err := hsdb.db.
-		Preload("Machine").
-		Where("machine_id = ? AND advertised = true", machine.ID).
+		Preload("Node").
+		Where("node_id = ? AND advertised = true", node.ID).
 		Find(&routes).Error
 	if err != nil {
 		return nil, err
@@ -49,18 +49,18 @@ func (hsdb *HSDatabase) getMachineAdvertisedRoutes(machine *types.Machine) (type
 	return routes, nil
 }
 
-func (hsdb *HSDatabase) GetMachineRoutes(m *types.Machine) (types.Routes, error) {
+func (hsdb *HSDatabase) GetNodeRoutes(node *types.Node) (types.Routes, error) {
 	hsdb.mu.RLock()
 	defer hsdb.mu.RUnlock()
 
-	return hsdb.getMachineRoutes(m)
+	return hsdb.getNodeRoutes(node)
 }
 
-func (hsdb *HSDatabase) getMachineRoutes(m *types.Machine) (types.Routes, error) {
+func (hsdb *HSDatabase) getNodeRoutes(node *types.Node) (types.Routes, error) {
 	var routes types.Routes
 	err := hsdb.db.
-		Preload("Machine").
-		Where("machine_id = ?", m.ID).
+		Preload("Node").
+		Where("node_id = ?", node.ID).
 		Find(&routes).Error
 	if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
 		return nil, err
@@ -78,7 +78,7 @@ func (hsdb *HSDatabase) GetRoute(id uint64) (*types.Route, error) {
 
 func (hsdb *HSDatabase) getRoute(id uint64) (*types.Route, error) {
 	var route types.Route
-	err := hsdb.db.Preload("Machine").First(&route, id).Error
+	err := hsdb.db.Preload("Node").First(&route, id).Error
 	if err != nil {
 		return nil, err
 	}
@@ -104,13 +104,13 @@ func (hsdb *HSDatabase) enableRoute(id uint64) error {
 	// https://github.com/juanfont/headscale/issues/804#issuecomment-1399314002
 	if route.IsExitRoute() {
 		return hsdb.enableRoutes(
-			&route.Machine,
+			&route.Node,
 			types.ExitRouteV4.String(),
 			types.ExitRouteV6.String(),
 		)
 	}
 
-	return hsdb.enableRoutes(&route.Machine, netip.Prefix(route.Prefix).String())
+	return hsdb.enableRoutes(&route.Node, netip.Prefix(route.Prefix).String())
 }
 
 func (hsdb *HSDatabase) DisableRoute(id uint64) error {
@@ -136,7 +136,7 @@ func (hsdb *HSDatabase) DisableRoute(id uint64) error {
 		return hsdb.handlePrimarySubnetFailover()
 	}
 
-	routes, err := hsdb.getMachineRoutes(&route.Machine)
+	routes, err := hsdb.getNodeRoutes(&route.Node)
 	if err != nil {
 		return err
 	}
@@ -175,7 +175,7 @@ func (hsdb *HSDatabase) DeleteRoute(id uint64) error {
 		return hsdb.handlePrimarySubnetFailover()
 	}
 
-	routes, err := hsdb.getMachineRoutes(&route.Machine)
+	routes, err := hsdb.getNodeRoutes(&route.Node)
 	if err != nil {
 		return err
 	}
@@ -194,8 +194,8 @@ func (hsdb *HSDatabase) DeleteRoute(id uint64) error {
 	return hsdb.handlePrimarySubnetFailover()
 }
 
-func (hsdb *HSDatabase) deleteMachineRoutes(m *types.Machine) error {
-	routes, err := hsdb.getMachineRoutes(m)
+func (hsdb *HSDatabase) deleteNodeRoutes(node *types.Node) error {
+	routes, err := hsdb.getNodeRoutes(node)
 	if err != nil {
 		return err
 	}
@@ -209,14 +209,14 @@ func (hsdb *HSDatabase) deleteMachineRoutes(m *types.Machine) error {
 	return hsdb.handlePrimarySubnetFailover()
 }
 
-// isUniquePrefix returns if there is another machine providing the same route already.
+// isUniquePrefix returns if there is another node providing the same route already.
 func (hsdb *HSDatabase) isUniquePrefix(route types.Route) bool {
 	var count int64
 	hsdb.db.
 		Model(&types.Route{}).
-		Where("prefix = ? AND machine_id != ? AND advertised = ? AND enabled = ?",
+		Where("prefix = ? AND node_id != ? AND advertised = ? AND enabled = ?",
 			route.Prefix,
-			route.MachineID,
+			route.NodeID,
 			true, true).Count(&count)
 
 	return count == 0
@@ -225,7 +225,7 @@ func (hsdb *HSDatabase) isUniquePrefix(route types.Route) bool {
 func (hsdb *HSDatabase) getPrimaryRoute(prefix netip.Prefix) (*types.Route, error) {
 	var route types.Route
 	err := hsdb.db.
-		Preload("Machine").
+		Preload("Node").
 		Where("prefix = ? AND advertised = ? AND enabled = ? AND is_primary = ?", types.IPPrefix(prefix), true, true, true).
 		First(&route).Error
 	if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
@@ -239,16 +239,16 @@ func (hsdb *HSDatabase) getPrimaryRoute(prefix netip.Prefix) (*types.Route, erro
 	return &route, nil
 }
 
-// getMachinePrimaryRoutes returns the routes that are enabled and marked as primary (for subnet failover)
+// getNodePrimaryRoutes returns the routes that are enabled and marked as primary (for subnet failover)
 // Exit nodes are not considered for this, as they are never marked as Primary.
-func (hsdb *HSDatabase) GetMachinePrimaryRoutes(machine *types.Machine) (types.Routes, error) {
+func (hsdb *HSDatabase) GetNodePrimaryRoutes(node *types.Node) (types.Routes, error) {
 	hsdb.mu.RLock()
 	defer hsdb.mu.RUnlock()
 
 	var routes types.Routes
 	err := hsdb.db.
-		Preload("Machine").
-		Where("machine_id = ? AND advertised = ? AND enabled = ? AND is_primary = ?", machine.ID, true, true, true).
+		Preload("Node").
+		Where("node_id = ? AND advertised = ? AND enabled = ? AND is_primary = ?", node.ID, true, true, true).
 		Find(&routes).Error
 	if err != nil {
 		return nil, err
@@ -257,29 +257,29 @@ func (hsdb *HSDatabase) GetMachinePrimaryRoutes(machine *types.Machine) (types.R
 	return routes, nil
 }
 
-// SaveMachineRoutes takes a machine and updates the database with
+// SaveNodeRoutes takes a node and updates the database with
 // the new routes.
-func (hsdb *HSDatabase) SaveMachineRoutes(machine *types.Machine) error {
+func (hsdb *HSDatabase) SaveNodeRoutes(node *types.Node) error {
 	hsdb.mu.Lock()
 	defer hsdb.mu.Unlock()
 
-	return hsdb.saveMachineRoutes(machine)
+	return hsdb.saveNodeRoutes(node)
 }
 
-func (hsdb *HSDatabase) saveMachineRoutes(machine *types.Machine) error {
+func (hsdb *HSDatabase) saveNodeRoutes(node *types.Node) error {
 	currentRoutes := types.Routes{}
-	err := hsdb.db.Where("machine_id = ?", machine.ID).Find(&currentRoutes).Error
+	err := hsdb.db.Where("node_id = ?", node.ID).Find(&currentRoutes).Error
 	if err != nil {
 		return err
 	}
 
 	advertisedRoutes := map[netip.Prefix]bool{}
-	for _, prefix := range machine.HostInfo.RoutableIPs {
+	for _, prefix := range node.HostInfo.RoutableIPs {
 		advertisedRoutes[prefix] = false
 	}
 
 	log.Trace().
-		Str("machine", machine.Hostname).
+		Str("node", node.Hostname).
 		Interface("advertisedRoutes", advertisedRoutes).
 		Interface("currentRoutes", currentRoutes).
 		Msg("updating routes")
@@ -307,7 +307,7 @@ func (hsdb *HSDatabase) saveMachineRoutes(machine *types.Machine) error {
 	for prefix, exists := range advertisedRoutes {
 		if !exists {
 			route := types.Route{
-				MachineID:  machine.ID,
+				NodeID:     node.ID,
 				Prefix:     types.IPPrefix(prefix),
 				Advertised: true,
 				Enabled:    false,
@@ -333,27 +333,27 @@ func (hsdb *HSDatabase) handlePrimarySubnetFailover() error {
 	// first, get all the enabled routes
 	var routes types.Routes
 	err := hsdb.db.
-		Preload("Machine").
+		Preload("Node").
 		Where("advertised = ? AND enabled = ?", true, true).
 		Find(&routes).Error
 	if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
 		log.Error().Err(err).Msg("error getting routes")
 	}
 
-	changedMachines := make(types.Machines, 0)
+	changedNodes := make(types.Nodes, 0)
 	for pos, route := range routes {
 		if route.IsExitRoute() {
 			continue
 		}
 
-		machine := &route.Machine
+		node := &route.Node
 
 		if !route.IsPrimary {
 			_, err := hsdb.getPrimaryRoute(netip.Prefix(route.Prefix))
 			if hsdb.isUniquePrefix(route) || errors.Is(err, gorm.ErrRecordNotFound) {
 				log.Info().
 					Str("prefix", netip.Prefix(route.Prefix).String()).
-					Str("machine", route.Machine.GivenName).
+					Str("node", route.Node.GivenName).
 					Msg("Setting primary route")
 				routes[pos].IsPrimary = true
 				err := hsdb.db.Save(&routes[pos]).Error
@@ -363,30 +363,30 @@ func (hsdb *HSDatabase) handlePrimarySubnetFailover() error {
 					return err
 				}
 
-				changedMachines = append(changedMachines, machine)
+				changedNodes = append(changedNodes, node)
 
 				continue
 			}
 		}
 
 		if route.IsPrimary {
-			if route.Machine.IsOnline() {
+			if route.Node.IsOnline() {
 				continue
 			}
 
-			// machine offline, find a new primary
+			// node offline, find a new primary
 			log.Info().
-				Str("machine", route.Machine.Hostname).
+				Str("node", route.Node.Hostname).
 				Str("prefix", netip.Prefix(route.Prefix).String()).
-				Msgf("machine offline, finding a new primary subnet")
+				Msgf("node offline, finding a new primary subnet")
 
 			// find a new primary route
 			var newPrimaryRoutes types.Routes
 			err := hsdb.db.
-				Preload("Machine").
-				Where("prefix = ? AND machine_id != ? AND advertised = ? AND enabled = ?",
+				Preload("Node").
+				Where("prefix = ? AND node_id != ? AND advertised = ? AND enabled = ?",
 					route.Prefix,
-					route.MachineID,
+					route.NodeID,
 					true, true).
 				Find(&newPrimaryRoutes).Error
 			if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
@@ -397,7 +397,7 @@ func (hsdb *HSDatabase) handlePrimarySubnetFailover() error {
 
 			var newPrimaryRoute *types.Route
 			for pos, r := range newPrimaryRoutes {
-				if r.Machine.IsOnline() {
+				if r.Node.IsOnline() {
 					newPrimaryRoute = &newPrimaryRoutes[pos]
 
 					break
@@ -406,7 +406,7 @@ func (hsdb *HSDatabase) handlePrimarySubnetFailover() error {
 
 			if newPrimaryRoute == nil {
 				log.Warn().
-					Str("machine", route.Machine.Hostname).
+					Str("node", route.Node.Hostname).
 					Str("prefix", netip.Prefix(route.Prefix).String()).
 					Msgf("no alternative primary route found")
 
@@ -414,9 +414,9 @@ func (hsdb *HSDatabase) handlePrimarySubnetFailover() error {
 			}
 
 			log.Info().
-				Str("old_machine", route.Machine.Hostname).
+				Str("old_node", route.Node.Hostname).
 				Str("prefix", netip.Prefix(route.Prefix).String()).
-				Str("new_machine", newPrimaryRoute.Machine.Hostname).
+				Str("new_node", newPrimaryRoute.Node.Hostname).
 				Msgf("found new primary route")
 
 			// disable the old primary route
@@ -437,39 +437,39 @@ func (hsdb *HSDatabase) handlePrimarySubnetFailover() error {
 				return err
 			}
 
-			changedMachines = append(changedMachines, machine)
+			changedNodes = append(changedNodes, node)
 		}
 	}
 
-	if len(changedMachines) > 0 {
+	if len(changedNodes) > 0 {
 		hsdb.notifier.NotifyAll(types.StateUpdate{
 			Type:    types.StatePeerChanged,
-			Changed: changedMachines,
+			Changed: changedNodes,
 		})
 	}
 
 	return nil
 }
 
-// EnableAutoApprovedRoutes enables any routes advertised by a machine that match the ACL autoApprovers policy.
+// EnableAutoApprovedRoutes enables any routes advertised by a node that match the ACL autoApprovers policy.
 func (hsdb *HSDatabase) EnableAutoApprovedRoutes(
 	aclPolicy *policy.ACLPolicy,
-	machine *types.Machine,
+	node *types.Node,
 ) error {
 	hsdb.mu.Lock()
 	defer hsdb.mu.Unlock()
 
-	if len(machine.IPAddresses) == 0 {
-		return nil // This machine has no IPAddresses, so can't possibly match any autoApprovers ACLs
+	if len(node.IPAddresses) == 0 {
+		return nil // This node has no IPAddresses, so can't possibly match any autoApprovers ACLs
 	}
 
-	routes, err := hsdb.getMachineAdvertisedRoutes(machine)
+	routes, err := hsdb.getNodeAdvertisedRoutes(node)
 	if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
 		log.Error().
 			Caller().
 			Err(err).
-			Str("machine", machine.Hostname).
-			Msg("Could not get advertised routes for machine")
+			Str("node", node.Hostname).
+			Msg("Could not get advertised routes for node")
 
 		return err
 	}
@@ -487,18 +487,18 @@ func (hsdb *HSDatabase) EnableAutoApprovedRoutes(
 		if err != nil {
 			log.Err(err).
 				Str("advertisedRoute", advertisedRoute.String()).
-				Uint64("machineId", machine.ID).
+				Uint64("nodeId", node.ID).
 				Msg("Failed to resolve autoApprovers for advertised route")
 
 			return err
 		}
 
 		for _, approvedAlias := range routeApprovers {
-			if approvedAlias == machine.User.Name {
+			if approvedAlias == node.User.Name {
 				approvedRoutes = append(approvedRoutes, advertisedRoute)
 			} else {
 				// TODO(kradalby): figure out how to get this to depend on less stuff
-				approvedIps, err := aclPolicy.ExpandAlias(types.Machines{machine}, approvedAlias)
+				approvedIps, err := aclPolicy.ExpandAlias(types.Nodes{node}, approvedAlias)
 				if err != nil {
 					log.Err(err).
 						Str("alias", approvedAlias).
@@ -507,8 +507,8 @@ func (hsdb *HSDatabase) EnableAutoApprovedRoutes(
 					return err
 				}
 
-				// approvedIPs should contain all of machine's IPs if it matches the rule, so check for first
-				if approvedIps.Contains(machine.IPAddresses[0]) {
+				// approvedIPs should contain all of node's IPs if it matches the rule, so check for first
+				if approvedIps.Contains(node.IPAddresses[0]) {
 					approvedRoutes = append(approvedRoutes, advertisedRoute)
 				}
 			}
@@ -520,7 +520,7 @@ func (hsdb *HSDatabase) EnableAutoApprovedRoutes(
 		if err != nil {
 			log.Err(err).
 				Str("approvedRoute", approvedRoute.String()).
-				Uint64("machineId", machine.ID).
+				Uint64("nodeId", node.ID).
 				Msg("Failed to enable approved route")
 
 			return err
diff --git a/hscontrol/db/routes_test.go b/hscontrol/db/routes_test.go
index 4698be28fa..ba5882b591 100644
--- a/hscontrol/db/routes_test.go
+++ b/hscontrol/db/routes_test.go
@@ -17,7 +17,7 @@ func (s *Suite) TestGetRoutes(c *check.C) {
 	pak, err := db.CreatePreAuthKey(user.Name, false, false, nil, nil)
 	c.Assert(err, check.IsNil)
 
-	_, err = db.GetMachine("test", "test_get_route_machine")
+	_, err = db.GetNode("test", "test_get_route_node")
 	c.Assert(err, check.NotNil)
 
 	route, err := netip.ParsePrefix("10.0.0.0/24")
@@ -27,30 +27,30 @@ func (s *Suite) TestGetRoutes(c *check.C) {
 		RoutableIPs: []netip.Prefix{route},
 	}
 
-	machine := types.Machine{
+	node := types.Node{
 		ID:             0,
 		MachineKey:     "foo",
 		NodeKey:        "bar",
 		DiscoKey:       "faa",
-		Hostname:       "test_get_route_machine",
+		Hostname:       "test_get_route_node",
 		UserID:         user.ID,
 		RegisterMethod: util.RegisterMethodAuthKey,
 		AuthKeyID:      uint(pak.ID),
 		HostInfo:       types.HostInfo(hostInfo),
 	}
-	db.db.Save(&machine)
+	db.db.Save(&node)
 
-	err = db.SaveMachineRoutes(&machine)
+	err = db.SaveNodeRoutes(&node)
 	c.Assert(err, check.IsNil)
 
-	advertisedRoutes, err := db.GetAdvertisedRoutes(&machine)
+	advertisedRoutes, err := db.GetAdvertisedRoutes(&node)
 	c.Assert(err, check.IsNil)
 	c.Assert(len(advertisedRoutes), check.Equals, 1)
 
-	err = db.enableRoutes(&machine, "192.168.0.0/24")
+	err = db.enableRoutes(&node, "192.168.0.0/24")
 	c.Assert(err, check.NotNil)
 
-	err = db.enableRoutes(&machine, "10.0.0.0/24")
+	err = db.enableRoutes(&node, "10.0.0.0/24")
 	c.Assert(err, check.IsNil)
 }
 
@@ -61,7 +61,7 @@ func (s *Suite) TestGetEnableRoutes(c *check.C) {
 	pak, err := db.CreatePreAuthKey(user.Name, false, false, nil, nil)
 	c.Assert(err, check.IsNil)
 
-	_, err = db.GetMachine("test", "test_enable_route_machine")
+	_, err = db.GetNode("test", "test_enable_route_node")
 	c.Assert(err, check.NotNil)
 
 	route, err := netip.ParsePrefix(
@@ -78,53 +78,53 @@ func (s *Suite) TestGetEnableRoutes(c *check.C) {
 		RoutableIPs: []netip.Prefix{route, route2},
 	}
 
-	machine := types.Machine{
+	node := types.Node{
 		ID:             0,
 		MachineKey:     "foo",
 		NodeKey:        "bar",
 		DiscoKey:       "faa",
-		Hostname:       "test_enable_route_machine",
+		Hostname:       "test_enable_route_node",
 		UserID:         user.ID,
 		RegisterMethod: util.RegisterMethodAuthKey,
 		AuthKeyID:      uint(pak.ID),
 		HostInfo:       types.HostInfo(hostInfo),
 	}
-	db.db.Save(&machine)
+	db.db.Save(&node)
 
-	err = db.SaveMachineRoutes(&machine)
+	err = db.SaveNodeRoutes(&node)
 	c.Assert(err, check.IsNil)
 
-	availableRoutes, err := db.GetAdvertisedRoutes(&machine)
+	availableRoutes, err := db.GetAdvertisedRoutes(&node)
 	c.Assert(err, check.IsNil)
 	c.Assert(err, check.IsNil)
 	c.Assert(len(availableRoutes), check.Equals, 2)
 
-	noEnabledRoutes, err := db.GetEnabledRoutes(&machine)
+	noEnabledRoutes, err := db.GetEnabledRoutes(&node)
 	c.Assert(err, check.IsNil)
 	c.Assert(len(noEnabledRoutes), check.Equals, 0)
 
-	err = db.enableRoutes(&machine, "192.168.0.0/24")
+	err = db.enableRoutes(&node, "192.168.0.0/24")
 	c.Assert(err, check.NotNil)
 
-	err = db.enableRoutes(&machine, "10.0.0.0/24")
+	err = db.enableRoutes(&node, "10.0.0.0/24")
 	c.Assert(err, check.IsNil)
 
-	enabledRoutes, err := db.GetEnabledRoutes(&machine)
+	enabledRoutes, err := db.GetEnabledRoutes(&node)
 	c.Assert(err, check.IsNil)
 	c.Assert(len(enabledRoutes), check.Equals, 1)
 
 	// Adding it twice will just let it pass through
-	err = db.enableRoutes(&machine, "10.0.0.0/24")
+	err = db.enableRoutes(&node, "10.0.0.0/24")
 	c.Assert(err, check.IsNil)
 
-	enableRoutesAfterDoubleApply, err := db.GetEnabledRoutes(&machine)
+	enableRoutesAfterDoubleApply, err := db.GetEnabledRoutes(&node)
 	c.Assert(err, check.IsNil)
 	c.Assert(len(enableRoutesAfterDoubleApply), check.Equals, 1)
 
-	err = db.enableRoutes(&machine, "150.0.10.0/25")
+	err = db.enableRoutes(&node, "150.0.10.0/25")
 	c.Assert(err, check.IsNil)
 
-	enabledRoutesWithAdditionalRoute, err := db.GetEnabledRoutes(&machine)
+	enabledRoutesWithAdditionalRoute, err := db.GetEnabledRoutes(&node)
 	c.Assert(err, check.IsNil)
 	c.Assert(len(enabledRoutesWithAdditionalRoute), check.Equals, 2)
 }
@@ -136,7 +136,7 @@ func (s *Suite) TestIsUniquePrefix(c *check.C) {
 	pak, err := db.CreatePreAuthKey(user.Name, false, false, nil, nil)
 	c.Assert(err, check.IsNil)
 
-	_, err = db.GetMachine("test", "test_enable_route_machine")
+	_, err = db.GetNode("test", "test_enable_route_node")
 	c.Assert(err, check.NotNil)
 
 	route, err := netip.ParsePrefix(
@@ -152,63 +152,63 @@ func (s *Suite) TestIsUniquePrefix(c *check.C) {
 	hostInfo1 := tailcfg.Hostinfo{
 		RoutableIPs: []netip.Prefix{route, route2},
 	}
-	machine1 := types.Machine{
+	node1 := types.Node{
 		ID:             1,
 		MachineKey:     "foo",
 		NodeKey:        "bar",
 		DiscoKey:       "faa",
-		Hostname:       "test_enable_route_machine",
+		Hostname:       "test_enable_route_node",
 		UserID:         user.ID,
 		RegisterMethod: util.RegisterMethodAuthKey,
 		AuthKeyID:      uint(pak.ID),
 		HostInfo:       types.HostInfo(hostInfo1),
 	}
-	db.db.Save(&machine1)
+	db.db.Save(&node1)
 
-	err = db.SaveMachineRoutes(&machine1)
+	err = db.SaveNodeRoutes(&node1)
 	c.Assert(err, check.IsNil)
 
-	err = db.enableRoutes(&machine1, route.String())
+	err = db.enableRoutes(&node1, route.String())
 	c.Assert(err, check.IsNil)
 
-	err = db.enableRoutes(&machine1, route2.String())
+	err = db.enableRoutes(&node1, route2.String())
 	c.Assert(err, check.IsNil)
 
 	hostInfo2 := tailcfg.Hostinfo{
 		RoutableIPs: []netip.Prefix{route2},
 	}
-	machine2 := types.Machine{
+	node2 := types.Node{
 		ID:             2,
 		MachineKey:     "foo",
 		NodeKey:        "bar",
 		DiscoKey:       "faa",
-		Hostname:       "test_enable_route_machine",
+		Hostname:       "test_enable_route_node",
 		UserID:         user.ID,
 		RegisterMethod: util.RegisterMethodAuthKey,
 		AuthKeyID:      uint(pak.ID),
 		HostInfo:       types.HostInfo(hostInfo2),
 	}
-	db.db.Save(&machine2)
+	db.db.Save(&node2)
 
-	err = db.SaveMachineRoutes(&machine2)
+	err = db.SaveNodeRoutes(&node2)
 	c.Assert(err, check.IsNil)
 
-	err = db.enableRoutes(&machine2, route2.String())
+	err = db.enableRoutes(&node2, route2.String())
 	c.Assert(err, check.IsNil)
 
-	enabledRoutes1, err := db.GetEnabledRoutes(&machine1)
+	enabledRoutes1, err := db.GetEnabledRoutes(&node1)
 	c.Assert(err, check.IsNil)
 	c.Assert(len(enabledRoutes1), check.Equals, 2)
 
-	enabledRoutes2, err := db.GetEnabledRoutes(&machine2)
+	enabledRoutes2, err := db.GetEnabledRoutes(&node2)
 	c.Assert(err, check.IsNil)
 	c.Assert(len(enabledRoutes2), check.Equals, 1)
 
-	routes, err := db.GetMachinePrimaryRoutes(&machine1)
+	routes, err := db.GetNodePrimaryRoutes(&node1)
 	c.Assert(err, check.IsNil)
 	c.Assert(len(routes), check.Equals, 2)
 
-	routes, err = db.GetMachinePrimaryRoutes(&machine2)
+	routes, err = db.GetNodePrimaryRoutes(&node2)
 	c.Assert(err, check.IsNil)
 	c.Assert(len(routes), check.Equals, 0)
 }
@@ -220,7 +220,7 @@ func (s *Suite) TestSubnetFailover(c *check.C) {
 	pak, err := db.CreatePreAuthKey(user.Name, false, false, nil, nil)
 	c.Assert(err, check.IsNil)
 
-	_, err = db.GetMachine("test", "test_enable_route_machine")
+	_, err = db.GetNode("test", "test_enable_route_node")
 	c.Assert(err, check.NotNil)
 
 	prefix, err := netip.ParsePrefix(
@@ -238,119 +238,119 @@ func (s *Suite) TestSubnetFailover(c *check.C) {
 	}
 
 	now := time.Now()
-	machine1 := types.Machine{
+	node1 := types.Node{
 		ID:             1,
 		MachineKey:     "foo",
 		NodeKey:        "bar",
 		DiscoKey:       "faa",
-		Hostname:       "test_enable_route_machine",
+		Hostname:       "test_enable_route_node",
 		UserID:         user.ID,
 		RegisterMethod: util.RegisterMethodAuthKey,
 		AuthKeyID:      uint(pak.ID),
 		HostInfo:       types.HostInfo(hostInfo1),
 		LastSeen:       &now,
 	}
-	db.db.Save(&machine1)
+	db.db.Save(&node1)
 
-	err = db.SaveMachineRoutes(&machine1)
+	err = db.SaveNodeRoutes(&node1)
 	c.Assert(err, check.IsNil)
 
-	err = db.enableRoutes(&machine1, prefix.String())
+	err = db.enableRoutes(&node1, prefix.String())
 	c.Assert(err, check.IsNil)
 
-	err = db.enableRoutes(&machine1, prefix2.String())
+	err = db.enableRoutes(&node1, prefix2.String())
 	c.Assert(err, check.IsNil)
 
 	err = db.HandlePrimarySubnetFailover()
 	c.Assert(err, check.IsNil)
 
-	enabledRoutes1, err := db.GetEnabledRoutes(&machine1)
+	enabledRoutes1, err := db.GetEnabledRoutes(&node1)
 	c.Assert(err, check.IsNil)
 	c.Assert(len(enabledRoutes1), check.Equals, 2)
 
 	route, err := db.getPrimaryRoute(prefix)
 	c.Assert(err, check.IsNil)
-	c.Assert(route.MachineID, check.Equals, machine1.ID)
+	c.Assert(route.NodeID, check.Equals, node1.ID)
 
 	hostInfo2 := tailcfg.Hostinfo{
 		RoutableIPs: []netip.Prefix{prefix2},
 	}
-	machine2 := types.Machine{
+	node2 := types.Node{
 		ID:             2,
 		MachineKey:     "foo",
 		NodeKey:        "bar",
 		DiscoKey:       "faa",
-		Hostname:       "test_enable_route_machine",
+		Hostname:       "test_enable_route_node",
 		UserID:         user.ID,
 		RegisterMethod: util.RegisterMethodAuthKey,
 		AuthKeyID:      uint(pak.ID),
 		HostInfo:       types.HostInfo(hostInfo2),
 		LastSeen:       &now,
 	}
-	db.db.Save(&machine2)
+	db.db.Save(&node2)
 
-	err = db.SaveMachineRoutes(&machine2)
+	err = db.saveNodeRoutes(&node2)
 	c.Assert(err, check.IsNil)
 
-	err = db.enableRoutes(&machine2, prefix2.String())
+	err = db.enableRoutes(&node2, prefix2.String())
 	c.Assert(err, check.IsNil)
 
 	err = db.HandlePrimarySubnetFailover()
 	c.Assert(err, check.IsNil)
 
-	enabledRoutes1, err = db.GetEnabledRoutes(&machine1)
+	enabledRoutes1, err = db.GetEnabledRoutes(&node1)
 	c.Assert(err, check.IsNil)
 	c.Assert(len(enabledRoutes1), check.Equals, 2)
 
-	enabledRoutes2, err := db.GetEnabledRoutes(&machine2)
+	enabledRoutes2, err := db.GetEnabledRoutes(&node2)
 	c.Assert(err, check.IsNil)
 	c.Assert(len(enabledRoutes2), check.Equals, 1)
 
-	routes, err := db.GetMachinePrimaryRoutes(&machine1)
+	routes, err := db.GetNodePrimaryRoutes(&node1)
 	c.Assert(err, check.IsNil)
 	c.Assert(len(routes), check.Equals, 2)
 
-	routes, err = db.GetMachinePrimaryRoutes(&machine2)
+	routes, err = db.GetNodePrimaryRoutes(&node2)
 	c.Assert(err, check.IsNil)
 	c.Assert(len(routes), check.Equals, 0)
 
-	// lets make machine1 lastseen 10 mins ago
+	// lets make node1 lastseen 10 mins ago
 	before := now.Add(-10 * time.Minute)
-	machine1.LastSeen = &before
-	err = db.db.Save(&machine1).Error
+	node1.LastSeen = &before
+	err = db.db.Save(&node1).Error
 	c.Assert(err, check.IsNil)
 
 	err = db.HandlePrimarySubnetFailover()
 	c.Assert(err, check.IsNil)
 
-	routes, err = db.GetMachinePrimaryRoutes(&machine1)
+	routes, err = db.GetNodePrimaryRoutes(&node1)
 	c.Assert(err, check.IsNil)
 	c.Assert(len(routes), check.Equals, 1)
 
-	routes, err = db.GetMachinePrimaryRoutes(&machine2)
+	routes, err = db.GetNodePrimaryRoutes(&node2)
 	c.Assert(err, check.IsNil)
 	c.Assert(len(routes), check.Equals, 1)
 
-	machine2.HostInfo = types.HostInfo(tailcfg.Hostinfo{
+	node2.HostInfo = types.HostInfo(tailcfg.Hostinfo{
 		RoutableIPs: []netip.Prefix{prefix, prefix2},
 	})
-	err = db.db.Save(&machine2).Error
+	err = db.db.Save(&node2).Error
 	c.Assert(err, check.IsNil)
 
-	err = db.SaveMachineRoutes(&machine2)
+	err = db.SaveNodeRoutes(&node2)
 	c.Assert(err, check.IsNil)
 
-	err = db.enableRoutes(&machine2, prefix.String())
+	err = db.enableRoutes(&node2, prefix.String())
 	c.Assert(err, check.IsNil)
 
 	err = db.HandlePrimarySubnetFailover()
 	c.Assert(err, check.IsNil)
 
-	routes, err = db.GetMachinePrimaryRoutes(&machine1)
+	routes, err = db.GetNodePrimaryRoutes(&node1)
 	c.Assert(err, check.IsNil)
 	c.Assert(len(routes), check.Equals, 0)
 
-	routes, err = db.GetMachinePrimaryRoutes(&machine2)
+	routes, err = db.GetNodePrimaryRoutes(&node2)
 	c.Assert(err, check.IsNil)
 	c.Assert(len(routes), check.Equals, 2)
 }
@@ -362,7 +362,7 @@ func (s *Suite) TestDeleteRoutes(c *check.C) {
 	pak, err := db.CreatePreAuthKey(user.Name, false, false, nil, nil)
 	c.Assert(err, check.IsNil)
 
-	_, err = db.GetMachine("test", "test_enable_route_machine")
+	_, err = db.GetNode("test", "test_enable_route_node")
 	c.Assert(err, check.NotNil)
 
 	prefix, err := netip.ParsePrefix(
@@ -380,36 +380,36 @@ func (s *Suite) TestDeleteRoutes(c *check.C) {
 	}
 
 	now := time.Now()
-	machine1 := types.Machine{
+	node1 := types.Node{
 		ID:             1,
 		MachineKey:     "foo",
 		NodeKey:        "bar",
 		DiscoKey:       "faa",
-		Hostname:       "test_enable_route_machine",
+		Hostname:       "test_enable_route_node",
 		UserID:         user.ID,
 		RegisterMethod: util.RegisterMethodAuthKey,
 		AuthKeyID:      uint(pak.ID),
 		HostInfo:       types.HostInfo(hostInfo1),
 		LastSeen:       &now,
 	}
-	db.db.Save(&machine1)
+	db.db.Save(&node1)
 
-	err = db.SaveMachineRoutes(&machine1)
+	err = db.SaveNodeRoutes(&node1)
 	c.Assert(err, check.IsNil)
 
-	err = db.enableRoutes(&machine1, prefix.String())
+	err = db.enableRoutes(&node1, prefix.String())
 	c.Assert(err, check.IsNil)
 
-	err = db.enableRoutes(&machine1, prefix2.String())
+	err = db.enableRoutes(&node1, prefix2.String())
 	c.Assert(err, check.IsNil)
 
-	routes, err := db.GetMachineRoutes(&machine1)
+	routes, err := db.GetNodeRoutes(&node1)
 	c.Assert(err, check.IsNil)
 
 	err = db.DeleteRoute(uint64(routes[0].ID))
 	c.Assert(err, check.IsNil)
 
-	enabledRoutes1, err := db.GetEnabledRoutes(&machine1)
+	enabledRoutes1, err := db.GetEnabledRoutes(&node1)
 	c.Assert(err, check.IsNil)
 	c.Assert(len(enabledRoutes1), check.Equals, 1)
 }
diff --git a/hscontrol/db/users.go b/hscontrol/db/users.go
index 5af4660b7c..27a1406b98 100644
--- a/hscontrol/db/users.go
+++ b/hscontrol/db/users.go
@@ -43,7 +43,7 @@ func (hsdb *HSDatabase) CreateUser(name string) (*types.User, error) {
 }
 
 // DestroyUser destroys a User. Returns error if the User does
-// not exist or if there are machines associated with it.
+// not exist or if there are nodes associated with it.
 func (hsdb *HSDatabase) DestroyUser(name string) error {
 	hsdb.mu.Lock()
 	defer hsdb.mu.Unlock()
@@ -53,11 +53,11 @@ func (hsdb *HSDatabase) DestroyUser(name string) error {
 		return ErrUserNotFound
 	}
 
-	machines, err := hsdb.listMachinesByUser(name)
+	nodes, err := hsdb.listNodesByUser(name)
 	if err != nil {
 		return err
 	}
-	if len(machines) > 0 {
+	if len(nodes) > 0 {
 		return ErrUserStillHasNodes
 	}
 
@@ -148,15 +148,15 @@ func (hsdb *HSDatabase) listUsers() ([]types.User, error) {
 	return users, nil
 }
 
-// ListMachinesByUser gets all the nodes in a given user.
-func (hsdb *HSDatabase) ListMachinesByUser(name string) (types.Machines, error) {
+// ListNodesByUser gets all the nodes in a given user.
+func (hsdb *HSDatabase) ListNodesByUser(name string) (types.Nodes, error) {
 	hsdb.mu.RLock()
 	defer hsdb.mu.RUnlock()
 
-	return hsdb.listMachinesByUser(name)
+	return hsdb.listNodesByUser(name)
 }
 
-func (hsdb *HSDatabase) listMachinesByUser(name string) (types.Machines, error) {
+func (hsdb *HSDatabase) listNodesByUser(name string) (types.Nodes, error) {
 	err := util.CheckForFQDNRules(name)
 	if err != nil {
 		return nil, err
@@ -166,16 +166,16 @@ func (hsdb *HSDatabase) listMachinesByUser(name string) (types.Machines, error)
 		return nil, err
 	}
 
-	machines := types.Machines{}
-	if err := hsdb.db.Preload("AuthKey").Preload("AuthKey.User").Preload("User").Where(&types.Machine{UserID: user.ID}).Find(&machines).Error; err != nil {
+	nodes := types.Nodes{}
+	if err := hsdb.db.Preload("AuthKey").Preload("AuthKey.User").Preload("User").Where(&types.Node{UserID: user.ID}).Find(&nodes).Error; err != nil {
 		return nil, err
 	}
 
-	return machines, nil
+	return nodes, nil
 }
 
-// AssignMachineToUser assigns a Machine to a user.
-func (hsdb *HSDatabase) AssignMachineToUser(machine *types.Machine, username string) error {
+// AssignNodeToUser assigns a Node to a user.
+func (hsdb *HSDatabase) AssignNodeToUser(node *types.Node, username string) error {
 	hsdb.mu.Lock()
 	defer hsdb.mu.Unlock()
 
@@ -187,8 +187,8 @@ func (hsdb *HSDatabase) AssignMachineToUser(machine *types.Machine, username str
 	if err != nil {
 		return err
 	}
-	machine.User = *user
-	if result := hsdb.db.Save(&machine); result.Error != nil {
+	node.User = *user
+	if result := hsdb.db.Save(&node); result.Error != nil {
 		return result.Error
 	}
 
diff --git a/hscontrol/db/users_test.go b/hscontrol/db/users_test.go
index 97b3e6d7f6..0c43b979ba 100644
--- a/hscontrol/db/users_test.go
+++ b/hscontrol/db/users_test.go
@@ -46,17 +46,17 @@ func (s *Suite) TestDestroyUserErrors(c *check.C) {
 	pak, err = db.CreatePreAuthKey(user.Name, false, false, nil, nil)
 	c.Assert(err, check.IsNil)
 
-	machine := types.Machine{
+	node := types.Node{
 		ID:             0,
 		MachineKey:     "foo",
 		NodeKey:        "bar",
 		DiscoKey:       "faa",
-		Hostname:       "testmachine",
+		Hostname:       "testnode",
 		UserID:         user.ID,
 		RegisterMethod: util.RegisterMethodAuthKey,
 		AuthKeyID:      uint(pak.ID),
 	}
-	db.db.Save(&machine)
+	db.db.Save(&node)
 
 	err = db.DestroyUser("test")
 	c.Assert(err, check.Equals, ErrUserStillHasNodes)
@@ -101,29 +101,29 @@ func (s *Suite) TestSetMachineUser(c *check.C) {
 	pak, err := db.CreatePreAuthKey(oldUser.Name, false, false, nil, nil)
 	c.Assert(err, check.IsNil)
 
-	machine := types.Machine{
+	node := types.Node{
 		ID:             0,
 		MachineKey:     "foo",
 		NodeKey:        "bar",
 		DiscoKey:       "faa",
-		Hostname:       "testmachine",
+		Hostname:       "testnode",
 		UserID:         oldUser.ID,
 		RegisterMethod: util.RegisterMethodAuthKey,
 		AuthKeyID:      uint(pak.ID),
 	}
-	db.db.Save(&machine)
-	c.Assert(machine.UserID, check.Equals, oldUser.ID)
+	db.db.Save(&node)
+	c.Assert(node.UserID, check.Equals, oldUser.ID)
 
-	err = db.AssignMachineToUser(&machine, newUser.Name)
+	err = db.AssignNodeToUser(&node, newUser.Name)
 	c.Assert(err, check.IsNil)
-	c.Assert(machine.UserID, check.Equals, newUser.ID)
-	c.Assert(machine.User.Name, check.Equals, newUser.Name)
+	c.Assert(node.UserID, check.Equals, newUser.ID)
+	c.Assert(node.User.Name, check.Equals, newUser.Name)
 
-	err = db.AssignMachineToUser(&machine, "non-existing-user")
+	err = db.AssignNodeToUser(&node, "non-existing-user")
 	c.Assert(err, check.Equals, ErrUserNotFound)
 
-	err = db.AssignMachineToUser(&machine, newUser.Name)
+	err = db.AssignNodeToUser(&node, newUser.Name)
 	c.Assert(err, check.IsNil)
-	c.Assert(machine.UserID, check.Equals, newUser.ID)
-	c.Assert(machine.User.Name, check.Equals, newUser.Name)
+	c.Assert(node.UserID, check.Equals, newUser.ID)
+	c.Assert(node.User.Name, check.Equals, newUser.Name)
 }
diff --git a/hscontrol/grpcv1.go b/hscontrol/grpcv1.go
index d516ab9448..e04e3b1967 100644
--- a/hscontrol/grpcv1.go
+++ b/hscontrol/grpcv1.go
@@ -166,16 +166,16 @@ func (api headscaleV1APIServer) ListPreAuthKeys(
 	return &v1.ListPreAuthKeysResponse{PreAuthKeys: response}, nil
 }
 
-func (api headscaleV1APIServer) RegisterMachine(
+func (api headscaleV1APIServer) RegisterNode(
 	ctx context.Context,
-	request *v1.RegisterMachineRequest,
-) (*v1.RegisterMachineResponse, error) {
+	request *v1.RegisterNodeRequest,
+) (*v1.RegisterNodeResponse, error) {
 	log.Trace().
 		Str("user", request.GetUser()).
 		Str("node_key", request.GetKey()).
-		Msg("Registering machine")
+		Msg("Registering node")
 
-	machine, err := api.h.db.RegisterMachineFromAuthCallback(
+	node, err := api.h.db.RegisterNodeFromAuthCallback(
 		api.h.registrationCache,
 		request.GetKey(),
 		request.GetUser(),
@@ -186,26 +186,26 @@ func (api headscaleV1APIServer) RegisterMachine(
 		return nil, err
 	}
 
-	return &v1.RegisterMachineResponse{Machine: machine.Proto()}, nil
+	return &v1.RegisterNodeResponse{Node: node.Proto()}, nil
 }
 
-func (api headscaleV1APIServer) GetMachine(
+func (api headscaleV1APIServer) GetNode(
 	ctx context.Context,
-	request *v1.GetMachineRequest,
-) (*v1.GetMachineResponse, error) {
-	machine, err := api.h.db.GetMachineByID(request.GetMachineId())
+	request *v1.GetNodeRequest,
+) (*v1.GetNodeResponse, error) {
+	node, err := api.h.db.GetNodeByID(request.GetNodeId())
 	if err != nil {
 		return nil, err
 	}
 
-	return &v1.GetMachineResponse{Machine: machine.Proto()}, nil
+	return &v1.GetNodeResponse{Node: node.Proto()}, nil
 }
 
 func (api headscaleV1APIServer) SetTags(
 	ctx context.Context,
 	request *v1.SetTagsRequest,
 ) (*v1.SetTagsResponse, error) {
-	machine, err := api.h.db.GetMachineByID(request.GetMachineId())
+	node, err := api.h.db.GetNodeByID(request.GetNodeId())
 	if err != nil {
 		return nil, err
 	}
@@ -214,24 +214,24 @@ func (api headscaleV1APIServer) SetTags(
 		err := validateTag(tag)
 		if err != nil {
 			return &v1.SetTagsResponse{
-				Machine: nil,
+				Node: nil,
 			}, status.Error(codes.InvalidArgument, err.Error())
 		}
 	}
 
-	err = api.h.db.SetTags(machine, request.GetTags())
+	err = api.h.db.SetTags(node, request.GetTags())
 	if err != nil {
 		return &v1.SetTagsResponse{
-			Machine: nil,
+			Node: nil,
 		}, status.Error(codes.Internal, err.Error())
 	}
 
 	log.Trace().
-		Str("machine", machine.Hostname).
+		Str("node", node.Hostname).
 		Strs("tags", request.GetTags()).
-		Msg("Changing tags of machine")
+		Msg("Changing tags of node")
 
-	return &v1.SetTagsResponse{Machine: machine.Proto()}, nil
+	return &v1.SetTagsResponse{Node: node.Proto()}, nil
 }
 
 func validateTag(tag string) error {
@@ -247,60 +247,60 @@ func validateTag(tag string) error {
 	return nil
 }
 
-func (api headscaleV1APIServer) DeleteMachine(
+func (api headscaleV1APIServer) DeleteNode(
 	ctx context.Context,
-	request *v1.DeleteMachineRequest,
-) (*v1.DeleteMachineResponse, error) {
-	machine, err := api.h.db.GetMachineByID(request.GetMachineId())
+	request *v1.DeleteNodeRequest,
+) (*v1.DeleteNodeResponse, error) {
+	node, err := api.h.db.GetNodeByID(request.GetNodeId())
 	if err != nil {
 		return nil, err
 	}
 
-	err = api.h.db.DeleteMachine(
-		machine,
+	err = api.h.db.DeleteNode(
+		node,
 	)
 	if err != nil {
 		return nil, err
 	}
 
-	return &v1.DeleteMachineResponse{}, nil
+	return &v1.DeleteNodeResponse{}, nil
 }
 
-func (api headscaleV1APIServer) ExpireMachine(
+func (api headscaleV1APIServer) ExpireNode(
 	ctx context.Context,
-	request *v1.ExpireMachineRequest,
-) (*v1.ExpireMachineResponse, error) {
-	machine, err := api.h.db.GetMachineByID(request.GetMachineId())
+	request *v1.ExpireNodeRequest,
+) (*v1.ExpireNodeResponse, error) {
+	node, err := api.h.db.GetNodeByID(request.GetNodeId())
 	if err != nil {
 		return nil, err
 	}
 
 	now := time.Now()
 
-	api.h.db.MachineSetExpiry(
-		machine,
+	api.h.db.NodeSetExpiry(
+		node,
 		now,
 	)
 
 	log.Trace().
-		Str("machine", machine.Hostname).
-		Time("expiry", *machine.Expiry).
-		Msg("machine expired")
+		Str("node", node.Hostname).
+		Time("expiry", *node.Expiry).
+		Msg("node expired")
 
-	return &v1.ExpireMachineResponse{Machine: machine.Proto()}, nil
+	return &v1.ExpireNodeResponse{Node: node.Proto()}, nil
 }
 
-func (api headscaleV1APIServer) RenameMachine(
+func (api headscaleV1APIServer) RenameNode(
 	ctx context.Context,
-	request *v1.RenameMachineRequest,
-) (*v1.RenameMachineResponse, error) {
-	machine, err := api.h.db.GetMachineByID(request.GetMachineId())
+	request *v1.RenameNodeRequest,
+) (*v1.RenameNodeResponse, error) {
+	node, err := api.h.db.GetNodeByID(request.GetNodeId())
 	if err != nil {
 		return nil, err
 	}
 
-	err = api.h.db.RenameMachine(
-		machine,
+	err = api.h.db.RenameNode(
+		node,
 		request.GetNewName(),
 	)
 	if err != nil {
@@ -308,65 +308,65 @@ func (api headscaleV1APIServer) RenameMachine(
 	}
 
 	log.Trace().
-		Str("machine", machine.Hostname).
+		Str("node", node.Hostname).
 		Str("new_name", request.GetNewName()).
-		Msg("machine renamed")
+		Msg("node renamed")
 
-	return &v1.RenameMachineResponse{Machine: machine.Proto()}, nil
+	return &v1.RenameNodeResponse{Node: node.Proto()}, nil
 }
 
-func (api headscaleV1APIServer) ListMachines(
+func (api headscaleV1APIServer) ListNodes(
 	ctx context.Context,
-	request *v1.ListMachinesRequest,
-) (*v1.ListMachinesResponse, error) {
+	request *v1.ListNodesRequest,
+) (*v1.ListNodesResponse, error) {
 	if request.GetUser() != "" {
-		machines, err := api.h.db.ListMachinesByUser(request.GetUser())
+		nodes, err := api.h.db.ListNodesByUser(request.GetUser())
 		if err != nil {
 			return nil, err
 		}
 
-		response := make([]*v1.Machine, len(machines))
-		for index, machine := range machines {
-			response[index] = machine.Proto()
+		response := make([]*v1.Node, len(nodes))
+		for index, node := range nodes {
+			response[index] = node.Proto()
 		}
 
-		return &v1.ListMachinesResponse{Machines: response}, nil
+		return &v1.ListNodesResponse{Nodes: response}, nil
 	}
 
-	machines, err := api.h.db.ListMachines()
+	nodes, err := api.h.db.ListNodes()
 	if err != nil {
 		return nil, err
 	}
 
-	response := make([]*v1.Machine, len(machines))
-	for index, machine := range machines {
-		m := machine.Proto()
-		validTags, invalidTags := api.h.ACLPolicy.TagsOfMachine(
-			&machine,
+	response := make([]*v1.Node, len(nodes))
+	for index, node := range nodes {
+		m := node.Proto()
+		validTags, invalidTags := api.h.ACLPolicy.TagsOfNode(
+			&node,
 		)
 		m.InvalidTags = invalidTags
 		m.ValidTags = validTags
 		response[index] = m
 	}
 
-	return &v1.ListMachinesResponse{Machines: response}, nil
+	return &v1.ListNodesResponse{Nodes: response}, nil
 }
 
-func (api headscaleV1APIServer) MoveMachine(
+func (api headscaleV1APIServer) MoveNode(
 	ctx context.Context,
-	request *v1.MoveMachineRequest,
-) (*v1.MoveMachineResponse, error) {
-	machine, err := api.h.db.GetMachineByID(request.GetMachineId())
+	request *v1.MoveNodeRequest,
+) (*v1.MoveNodeResponse, error) {
+	node, err := api.h.db.GetNodeByID(request.GetNodeId())
 	if err != nil {
 		return nil, err
 	}
 
-	err = api.h.db.AssignMachineToUser(machine, request.GetUser())
+	err = api.h.db.AssignNodeToUser(node, request.GetUser())
 	if err != nil {
 		return nil, err
 	}
 
-	return &v1.MoveMachineResponse{Machine: machine.Proto()}, nil
+	return &v1.MoveNodeResponse{Node: node.Proto()}, nil
 }
 
 func (api headscaleV1APIServer) GetRoutes(
@@ -407,21 +407,21 @@ func (api headscaleV1APIServer) DisableRoute(
 	return &v1.DisableRouteResponse{}, nil
 }
 
-func (api headscaleV1APIServer) GetMachineRoutes(
+func (api headscaleV1APIServer) GetNodeRoutes(
 	ctx context.Context,
-	request *v1.GetMachineRoutesRequest,
-) (*v1.GetMachineRoutesResponse, error) {
-	machine, err := api.h.db.GetMachineByID(request.GetMachineId())
+	request *v1.GetNodeRoutesRequest,
+) (*v1.GetNodeRoutesResponse, error) {
+	node, err := api.h.db.GetNodeByID(request.GetNodeId())
 	if err != nil {
 		return nil, err
 	}
 
-	routes, err := api.h.db.GetMachineRoutes(machine)
+	routes, err := api.h.db.GetNodeRoutes(node)
 	if err != nil {
 		return nil, err
 	}
 
-	return &v1.GetMachineRoutesResponse{
+	return &v1.GetNodeRoutesResponse{
 		Routes: types.Routes(routes).Proto(),
 	}, nil
 }
@@ -495,10 +495,10 @@ func (api headscaleV1APIServer) ListApiKeys(
 }
 
 // The following service calls are for testing and debugging
-func (api headscaleV1APIServer) DebugCreateMachine(
+func (api headscaleV1APIServer) DebugCreateNode(
 	ctx context.Context,
-	request *v1.DebugCreateMachineRequest,
-) (*v1.DebugCreateMachineResponse, error) {
+	request *v1.DebugCreateNodeRequest,
+) (*v1.DebugCreateNodeResponse, error) {
 	user, err := api.h.db.GetUser(request.GetUser())
 	if err != nil {
 		return nil, err
@@ -518,7 +518,7 @@ func (api headscaleV1APIServer) DebugCreateMachine(
 	hostinfo := tailcfg.Hostinfo{
 		RoutableIPs: routes,
 		OS:          "TestOS",
-		Hostname:    "DebugTestMachine",
+		Hostname:    "DebugTestNode",
 	}
 
 	givenName, err := api.h.db.GenerateGivenName(request.GetKey(), request.GetName())
@@ -526,7 +526,7 @@ func (api headscaleV1APIServer) DebugCreateMachine(
 		return nil, err
 	}
 
-	newMachine := types.Machine{
+	newNode := types.Node{
 		MachineKey: request.GetKey(),
 		Hostname:   request.GetName(),
 		GivenName:  givenName,
@@ -541,16 +541,16 @@ func (api headscaleV1APIServer) DebugCreateMachine(
 	nodeKey := key.NodePublic{}
 	err = nodeKey.UnmarshalText([]byte(request.GetKey()))
 	if err != nil {
-		log.Panic().Msg("can not add machine for debug. invalid node key")
+		log.Panic().Msg("can not add node for debug. invalid node key")
 	}
 
 	api.h.registrationCache.Set(
 		util.NodePublicKeyStripPrefix(nodeKey),
-		newMachine,
+		newNode,
 		registerCacheExpiration,
 	)
 
-	return &v1.DebugCreateMachineResponse{Machine: newMachine.Proto()}, nil
+	return &v1.DebugCreateNodeResponse{Node: newNode.Proto()}, nil
 }
 
 func (api headscaleV1APIServer) mustEmbedUnimplementedHeadscaleServiceServer() {}
diff --git a/hscontrol/mapper/mapper.go b/hscontrol/mapper/mapper.go
index 0d34ebe162..c971f56436 100644
--- a/hscontrol/mapper/mapper.go
+++ b/hscontrol/mapper/mapper.go
@@ -41,7 +41,7 @@ var debugDumpMapResponsePath = envknob.String("HEADSCALE_DEBUG_DUMP_MAPRESPONSE_
 // TODO: Optimise
 // As this work continues, the idea is that there will be one Mapper instance
 // per node, attached to the open stream between the control and client.
-// This means that this can hold a state per machine and we can use that to
+// This means that this can hold a state per node and we can use that to
 // improve the mapresponses sent.
 // We could:
 // - Keep information about the previous mapresponse so we can send a diff
@@ -67,12 +67,12 @@ type Mapper struct {
 	// Map isnt concurrency safe, so we need to ensure
 	// only one func is accessing it over time.
 	mu    sync.Mutex
-	peers map[uint64]*types.Machine
+	peers map[uint64]*types.Node
 }
 
 func NewMapper(
-	machine *types.Machine,
-	peers types.Machines,
+	node *types.Node,
+	peers types.Nodes,
 	privateKey *key.MachinePrivate,
 	isNoise bool,
 	derpMap *tailcfg.DERPMap,
@@ -84,7 +84,7 @@ func NewMapper(
 	log.Debug().
 		Caller().
 		Bool("noise", isNoise).
-		Str("machine", machine.Hostname).
+		Str("node", node.Hostname).
 		Msg("creating new mapper")
 
 	uid, _ := util.GenerateRandomStringDNSSafe(mapperIDLength)
@@ -113,12 +113,12 @@ func (m *Mapper) String() string {
 }
 
 func generateUserProfiles(
-	machine *types.Machine,
-	peers types.Machines,
+	node *types.Node,
+	peers types.Nodes,
 	baseDomain string,
 ) []tailcfg.UserProfile {
 	userMap := make(map[string]types.User)
-	userMap[machine.User.Name] = machine.User
+	userMap[node.User.Name] = node.User
 	for _, peer := range peers {
 		userMap[peer.User.Name] = peer.User // not worth checking if already is there
 	}
@@ -145,8 +145,8 @@ func generateUserProfiles(
 func generateDNSConfig(
 	base *tailcfg.DNSConfig,
 	baseDomain string,
-	machine *types.Machine,
-	peers types.Machines,
+	node *types.Node,
+	peers types.Nodes,
 ) *tailcfg.DNSConfig {
 	dnsConfig := base.Clone()
 
@@ -158,13 +158,13 @@ func generateDNSConfig(
 			dnsConfig.Domains,
 			fmt.Sprintf(
 				"%s.%s",
-				machine.User.Name,
+				node.User.Name,
 				baseDomain,
 			),
 		)
 
 		userSet := mapset.NewSet[types.User]()
-		userSet.Add(machine.User)
+		userSet.Add(node.User)
 		for _, p := range peers {
 			userSet.Add(p.User)
 		}
@@ -176,28 +176,28 @@ func generateDNSConfig(
 		dnsConfig = base
 	}
 
-	addNextDNSMetadata(dnsConfig.Resolvers, machine)
+	addNextDNSMetadata(dnsConfig.Resolvers, node)
 
 	return dnsConfig
 }
 
 // If any nextdns DoH resolvers are present in the list of resolvers it will
-// take metadata from the machine metadata and instruct tailscale to add it
+// take metadata from the node metadata and instruct tailscale to add it
 // to the requests. This makes it possible to identify from which device the
 // requests come in the NextDNS dashboard.
 //
 // This will produce a resolver like:
 // `https://dns.nextdns.io/<nextdns-id>?device_name=node-name&device_model=linux&device_ip=100.64.0.1`
-func addNextDNSMetadata(resolvers []*dnstype.Resolver, machine *types.Machine) {
+func addNextDNSMetadata(resolvers []*dnstype.Resolver, node *types.Node) {
 	for _, resolver := range resolvers {
 		if strings.HasPrefix(resolver.Addr, nextDNSDoHPrefix) {
 			attrs := url.Values{
-				"device_name":  []string{machine.Hostname},
-				"device_model": []string{machine.HostInfo.OS},
+				"device_name":  []string{node.Hostname},
+				"device_model": []string{node.HostInfo.OS},
 			}
 
-			if len(machine.IPAddresses) > 0 {
-				attrs.Add("device_ip", machine.IPAddresses[0].String())
+			if len(node.IPAddresses) > 0 {
+				attrs.Add("device_ip", node.IPAddresses[0].String())
 			}
 
 			resolver.Addr = fmt.Sprintf("%s?%s", resolver.Addr, attrs.Encode())
@@ -208,23 +208,23 @@ func addNextDNSMetadata(resolvers []*dnstype.Resolver, machine *types.Machine) {
 // fullMapResponse creates a complete MapResponse for a node.
 // It is a separate function to make testing easier.
 func (m *Mapper) fullMapResponse(
-	machine *types.Machine,
+	node *types.Node,
 	pol *policy.ACLPolicy,
 ) (*tailcfg.MapResponse, error) {
-	peers := machineMapToList(m.peers)
+	peers := nodeMapToList(m.peers)
 
-	resp, err := m.baseWithConfigMapResponse(machine, pol)
+	resp, err := m.baseWithConfigMapResponse(node, pol)
 	if err != nil {
 		return nil, err
 	}
 
 	// TODO(kradalby): Move this into appendPeerChanges?
-	resp.OnlineChange = db.OnlineMachineMap(peers)
+	resp.OnlineChange = db.OnlineNodeMap(peers)
 
 	err = appendPeerChanges(
 		resp,
 		pol,
-		machine,
+		node,
 		peers,
 		peers,
 		m.baseDomain,
@@ -237,72 +237,72 @@ func (m *Mapper) fullMapResponse(
 	return resp, nil
 }
 
-// FullMapResponse returns a MapResponse for the given machine.
+// FullMapResponse returns a MapResponse for the given node.
 func (m *Mapper) FullMapResponse(
 	mapRequest tailcfg.MapRequest,
-	machine *types.Machine,
+	node *types.Node,
 	pol *policy.ACLPolicy,
 ) ([]byte, error) {
 	m.mu.Lock()
 	defer m.mu.Unlock()
 
-	resp, err := m.fullMapResponse(machine, pol)
+	resp, err := m.fullMapResponse(node, pol)
 	if err != nil {
 		return nil, err
 	}
 
 	if m.isNoise {
-		return m.marshalMapResponse(mapRequest, resp, machine, mapRequest.Compress)
+		return m.marshalMapResponse(mapRequest, resp, node, mapRequest.Compress)
 	}
 
-	return m.marshalMapResponse(mapRequest, resp, machine, mapRequest.Compress)
+	return m.marshalMapResponse(mapRequest, resp, node, mapRequest.Compress)
 }
 
-// LiteMapResponse returns a MapResponse for the given machine.
+// LiteMapResponse returns a MapResponse for the given node.
 // Lite means that the peers has been omitted, this is intended
 // to be used to answer MapRequests with OmitPeers set to true.
 func (m *Mapper) LiteMapResponse(
 	mapRequest tailcfg.MapRequest,
-	machine *types.Machine,
+	node *types.Node,
 	pol *policy.ACLPolicy,
 ) ([]byte, error) {
-	resp, err := m.baseWithConfigMapResponse(machine, pol)
+	resp, err := m.baseWithConfigMapResponse(node, pol)
 	if err != nil {
 		return nil, err
 	}
 
 	if m.isNoise {
-		return m.marshalMapResponse(mapRequest, resp, machine, mapRequest.Compress)
+		return m.marshalMapResponse(mapRequest, resp, node, mapRequest.Compress)
 	}
 
-	return m.marshalMapResponse(mapRequest, resp, machine, mapRequest.Compress)
+	return m.marshalMapResponse(mapRequest, resp, node, mapRequest.Compress)
 }
 
 func (m *Mapper) KeepAliveResponse(
 	mapRequest tailcfg.MapRequest,
-	machine *types.Machine,
+	node *types.Node,
 ) ([]byte, error) {
 	resp := m.baseMapResponse()
 	resp.KeepAlive = true
 
-	return m.marshalMapResponse(mapRequest, &resp, machine, mapRequest.Compress)
+	return m.marshalMapResponse(mapRequest, &resp, node, mapRequest.Compress)
 }
 
 func (m *Mapper) DERPMapResponse(
 	mapRequest tailcfg.MapRequest,
-	machine *types.Machine,
+	node *types.Node,
 	derpMap tailcfg.DERPMap,
 ) ([]byte, error) {
 	resp := m.baseMapResponse()
 	resp.DERPMap = &derpMap
 
-	return m.marshalMapResponse(mapRequest, &resp, machine, mapRequest.Compress)
+	return m.marshalMapResponse(mapRequest, &resp, node, mapRequest.Compress)
 }
 
 func (m *Mapper) PeerChangedResponse(
 	mapRequest tailcfg.MapRequest,
-	machine *types.Machine,
-	changed types.Machines,
+	node *types.Node,
+	changed types.Nodes,
 	pol *policy.ACLPolicy,
 ) ([]byte, error) {
 	m.mu.Lock()
@@ -311,11 +311,11 @@ func (m *Mapper) PeerChangedResponse(
 	lastSeen := make(map[tailcfg.NodeID]bool)
 
 	// Update our internal map.
-	for _, machine := range changed {
-		m.peers[machine.ID] = machine
+	for _, node := range changed {
+		m.peers[node.ID] = node
 
 		// We have just seen the node, let the peers update their list.
-		lastSeen[tailcfg.NodeID(machine.ID)] = true
+		lastSeen[tailcfg.NodeID(node.ID)] = true
 	}
 
 	resp := m.baseMapResponse()
@@ -323,8 +323,8 @@ func (m *Mapper) PeerChangedResponse(
 	err := appendPeerChanges(
 		&resp,
 		pol,
-		machine,
-		machineMapToList(m.peers),
+		node,
+		nodeMapToList(m.peers),
 		changed,
 		m.baseDomain,
 		m.dnsCfg,
@@ -335,12 +335,12 @@ func (m *Mapper) PeerChangedResponse(
 
 	// resp.PeerSeenChange = lastSeen
 
-	return m.marshalMapResponse(mapRequest, &resp, machine, mapRequest.Compress)
+	return m.marshalMapResponse(mapRequest, &resp, node, mapRequest.Compress)
 }
 
 func (m *Mapper) PeerRemovedResponse(
 	mapRequest tailcfg.MapRequest,
-	machine *types.Machine,
+	node *types.Node,
 	removed []tailcfg.NodeID,
 ) ([]byte, error) {
 	m.mu.Lock()
@@ -354,19 +354,19 @@ func (m *Mapper) PeerRemovedResponse(
 	resp := m.baseMapResponse()
 	resp.PeersRemoved = removed
 
-	return m.marshalMapResponse(mapRequest, &resp, machine, mapRequest.Compress)
+	return m.marshalMapResponse(mapRequest, &resp, node, mapRequest.Compress)
 }
 
 func (m *Mapper) marshalMapResponse(
 	mapRequest tailcfg.MapRequest,
 	resp *tailcfg.MapResponse,
-	machine *types.Machine,
+	node *types.Node,
 	compression string,
 ) ([]byte, error) {
 	atomic.AddUint64(&m.seq, 1)
 
 	var machineKey key.MachinePublic
-	err := machineKey.UnmarshalText([]byte(util.MachinePublicKeyEnsurePrefix(machine.MachineKey)))
+	err := machineKey.UnmarshalText([]byte(util.MachinePublicKeyEnsurePrefix(node.MachineKey)))
 	if err != nil {
 		log.Error().
 			Caller().
@@ -399,7 +399,7 @@ func (m *Mapper) marshalMapResponse(
 		}
 
 		perms := fs.FileMode(debugMapResponsePerm)
-		mPath := path.Join(debugDumpMapResponsePath, machine.Hostname)
+		mPath := path.Join(debugDumpMapResponsePath, node.Hostname)
 		err = os.MkdirAll(mPath, perms)
 		if err != nil {
 			panic(err)
@@ -509,12 +509,12 @@ func (m *Mapper) baseMapResponse() tailcfg.MapResponse {
 // It is used in for bigger updates, such as full and lite, not
 // incremental.
 func (m *Mapper) baseWithConfigMapResponse(
-	machine *types.Machine,
+	node *types.Node,
 	pol *policy.ACLPolicy,
 ) (*tailcfg.MapResponse, error) {
 	resp := m.baseMapResponse()
 
-	tailnode, err := tailNode(machine, pol, m.dnsCfg, m.baseDomain)
+	tailnode, err := tailNode(node, pol, m.dnsCfg, m.baseDomain)
 	if err != nil {
 		return nil, err
 	}
@@ -538,18 +538,18 @@ func (m *Mapper) baseWithConfigMapResponse(
 	return &resp, nil
 }
 
-func machineMapToList(machines map[uint64]*types.Machine) types.Machines {
-	ret := make(types.Machines, 0)
+func nodeMapToList(nodes map[uint64]*types.Node) types.Nodes {
+	ret := make(types.Nodes, 0)
 
-	for _, machine := range machines {
-		ret = append(ret, machine)
+	for _, node := range nodes {
+		ret = append(ret, node)
 	}
 
 	return ret
 }
 
-func filterExpiredAndNotReady(peers types.Machines) types.Machines {
-	return lo.Filter(peers, func(item *types.Machine, index int) bool {
+func filterExpiredAndNotReady(peers types.Nodes) types.Nodes {
+	return lo.Filter(peers, func(item *types.Node, index int) bool {
 		// Filter out nodes that are expired OR
 		// nodes that has no endpoints, this typically means they have
 		// registered, but are not configured.
@@ -563,9 +563,9 @@ func appendPeerChanges(
 	resp *tailcfg.MapResponse,
 
 	pol *policy.ACLPolicy,
-	machine *types.Machine,
-	peers types.Machines,
-	changed types.Machines,
+	node *types.Node,
+	peers types.Nodes,
+	changed types.Nodes,
 	baseDomain string,
 	dnsCfg *tailcfg.DNSConfig,
 ) error {
@@ -573,7 +573,7 @@ func appendPeerChanges(
 
 	rules, sshPolicy, err := policy.GenerateFilterAndSSHRules(
 		pol,
-		machine,
+		node,
 		peers,
 	)
 	if err != nil {
@@ -583,18 +583,18 @@ func appendPeerChanges(
 	// Filter out peers that have expired.
 	changed = filterExpiredAndNotReady(changed)
 
-	// If there are filter rules present, see if there are any machines that cannot
+	// If there are filter rules present, see if there are any nodes that cannot
 	// access eachother at all and remove them from the peers.
 	if len(rules) > 0 {
-		changed = policy.FilterMachinesByACL(machine, changed, rules)
+		changed = policy.FilterNodesByACL(node, changed, rules)
 	}
 
-	profiles := generateUserProfiles(machine, changed, baseDomain)
+	profiles := generateUserProfiles(node, changed, baseDomain)
 
 	dnsConfig := generateDNSConfig(
 		dnsCfg,
 		baseDomain,
-		machine,
+		node,
 		peers,
 	)
 
@@ -614,7 +614,7 @@ func appendPeerChanges(
 		resp.PeersChanged = tailPeers
 	}
 	resp.DNSConfig = dnsConfig
-	resp.PacketFilter = policy.ReduceFilterRules(machine, rules)
+	resp.PacketFilter = policy.ReduceFilterRules(node, rules)
 	resp.UserProfiles = profiles
 	resp.SSHPolicy = sshPolicy
 
diff --git a/hscontrol/mapper/mapper_test.go b/hscontrol/mapper/mapper_test.go
index c0857f2687..84cc9344f1 100644
--- a/hscontrol/mapper/mapper_test.go
+++ b/hscontrol/mapper/mapper_test.go
@@ -18,8 +18,8 @@ import (
 )
 
 func (s *Suite) TestGetMapResponseUserProfiles(c *check.C) {
-	mach := func(hostname, username string, userid uint) *types.Machine {
-		return &types.Machine{
+	mach := func(hostname, username string, userid uint) *types.Node {
+		return &types.Node{
 			Hostname: hostname,
 			UserID:   userid,
 			User: types.User{
@@ -28,15 +28,15 @@ func (s *Suite) TestGetMapResponseUserProfiles(c *check.C) {
 		}
 	}
 
-	machineInShared1 := mach("test_get_shared_nodes_1", "user1", 1)
-	machineInShared2 := mach("test_get_shared_nodes_2", "user2", 2)
-	machineInShared3 := mach("test_get_shared_nodes_3", "user3", 3)
-	machine2InShared1 := mach("test_get_shared_nodes_4", "user1", 1)
+	nodeInShared1 := mach("test_get_shared_nodes_1", "user1", 1)
+	nodeInShared2 := mach("test_get_shared_nodes_2", "user2", 2)
+	nodeInShared3 := mach("test_get_shared_nodes_3", "user3", 3)
+	node2InShared1 := mach("test_get_shared_nodes_4", "user1", 1)
 
 	userProfiles := generateUserProfiles(
-		machineInShared1,
-		types.Machines{
-			machineInShared2, machineInShared3, machine2InShared1,
+		nodeInShared1,
+		types.Nodes{
+			nodeInShared2, nodeInShared3, node2InShared1,
 		},
 		"",
 	)
@@ -91,8 +91,8 @@ func TestDNSConfigMapResponse(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(fmt.Sprintf("with-magicdns-%v", tt.magicDNS), func(t *testing.T) {
-			mach := func(hostname, username string, userid uint) *types.Machine {
-				return &types.Machine{
+			mach := func(hostname, username string, userid uint) *types.Node {
+				return &types.Node{
 					Hostname: hostname,
 					UserID:   userid,
 					User: types.User{
@@ -109,23 +109,23 @@ func TestDNSConfigMapResponse(t *testing.T) {
 				Proxied: tt.magicDNS,
 			}
 
-			machineInShared1 := mach("test_get_shared_nodes_1", "shared1", 1)
-			machineInShared2 := mach("test_get_shared_nodes_2", "shared2", 2)
-			machineInShared3 := mach("test_get_shared_nodes_3", "shared3", 3)
-			machine2InShared1 := mach("test_get_shared_nodes_4", "shared1", 1)
+			nodeInShared1 := mach("test_get_shared_nodes_1", "shared1", 1)
+			nodeInShared2 := mach("test_get_shared_nodes_2", "shared2", 2)
+			nodeInShared3 := mach("test_get_shared_nodes_3", "shared3", 3)
+			node2InShared1 := mach("test_get_shared_nodes_4", "shared1", 1)
 
-			peersOfMachineInShared1 := types.Machines{
-				machineInShared1,
-				machineInShared2,
-				machineInShared3,
-				machine2InShared1,
+			peersOfNodeInShared1 := types.Nodes{
+				nodeInShared1,
+				nodeInShared2,
+				nodeInShared3,
+				node2InShared1,
 			}
 
 			got := generateDNSConfig(
 				&dnsConfigOrig,
 				baseDomain,
-				machineInShared1,
-				peersOfMachineInShared1,
+				nodeInShared1,
+				peersOfNodeInShared1,
 			)
 
 			if diff := cmp.Diff(tt.want, got, cmpopts.EquateEmpty()); diff != "" {
@@ -165,7 +165,7 @@ func Test_fullMapResponse(t *testing.T) {
 	lastSeen := time.Date(2009, time.November, 10, 23, 9, 0, 0, time.UTC)
 	expire := time.Date(2500, time.November, 11, 23, 0, 0, 0, time.UTC)
 
-	mini := &types.Machine{
+	mini := &types.Node{
 		ID:          0,
 		MachineKey:  "mkey:f08305b4ee4250b95a70f3b7504d048d75d899993c624a26d422c67af0422507",
 		NodeKey:     "nodekey:9b2ffa7e08cc421a3d2cca9012280f6a236fd0de0b4ce005b30a98ad930306fe",
@@ -243,7 +243,7 @@ func Test_fullMapResponse(t *testing.T) {
 		},
 	}
 
-	peer1 := &types.Machine{
+	peer1 := &types.Node{
 		ID:          1,
 		MachineKey:  "mkey:f08305b4ee4250b95a70f3b7504d048d75d899993c624a26d422c67af0422507",
 		NodeKey:     "nodekey:9b2ffa7e08cc421a3d2cca9012280f6a236fd0de0b4ce005b30a98ad930306fe",
@@ -295,7 +295,7 @@ func Test_fullMapResponse(t *testing.T) {
 		},
 	}
 
-	peer2 := &types.Machine{
+	peer2 := &types.Node{
 		ID:          2,
 		MachineKey:  "mkey:f08305b4ee4250b95a70f3b7504d048d75d899993c624a26d422c67af0422507",
 		NodeKey:     "nodekey:9b2ffa7e08cc421a3d2cca9012280f6a236fd0de0b4ce005b30a98ad930306fe",
@@ -315,10 +315,10 @@ func Test_fullMapResponse(t *testing.T) {
 	}
 
 	tests := []struct {
-		name    string
-		pol     *policy.ACLPolicy
-		machine *types.Machine
-		peers   types.Machines
+		name  string
+		pol   *policy.ACLPolicy
+		node  *types.Node
+		peers types.Nodes
 
 		baseDomain       string
 		dnsConfig        *tailcfg.DNSConfig
@@ -329,8 +329,8 @@ func Test_fullMapResponse(t *testing.T) {
 		wantErr          bool
 	}{
 		// {
-		// 	name:             "empty-machine",
-		// 	machine:          types.Machine{},
+		// 	name:             "empty-node",
+		// 	node:          types.Node{},
 		// 	pol:              &policy.ACLPolicy{},
 		// 	dnsConfig:        &tailcfg.DNSConfig{},
 		// 	baseDomain:       "",
@@ -340,8 +340,8 @@ func Test_fullMapResponse(t *testing.T) {
 		{
 			name:             "no-pol-no-peers-map-response",
 			pol:              &policy.ACLPolicy{},
-			machine:          mini,
-			peers:            types.Machines{},
+			node:             mini,
+			peers:            types.Nodes{},
 			baseDomain:       "",
 			dnsConfig:        &tailcfg.DNSConfig{},
 			derpMap:          &tailcfg.DERPMap{},
@@ -366,10 +366,10 @@ func Test_fullMapResponse(t *testing.T) {
 			wantErr: false,
 		},
 		{
-			name:    "no-pol-with-peer-map-response",
-			pol:     &policy.ACLPolicy{},
-			machine: mini,
-			peers: types.Machines{
+			name: "no-pol-with-peer-map-response",
+			pol:  &policy.ACLPolicy{},
+			node: mini,
+			peers: types.Nodes{
 				peer1,
 			},
 			baseDomain:       "",
@@ -409,8 +409,8 @@ func Test_fullMapResponse(t *testing.T) {
 					},
 				},
 			},
-			machine: mini,
-			peers: types.Machines{
+			node: mini,
+			peers: types.Nodes{
 				peer1,
 				peer2,
 			},
@@ -457,7 +457,7 @@ func Test_fullMapResponse(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			mappy := NewMapper(
-				tt.machine,
+				tt.node,
 				tt.peers,
 				nil,
 				false,
@@ -469,7 +469,7 @@ func Test_fullMapResponse(t *testing.T) {
 			)
 
 			got, err := mappy.fullMapResponse(
-				tt.machine,
+				tt.node,
 				tt.pol,
 			)
 
diff --git a/hscontrol/mapper/tail.go b/hscontrol/mapper/tail.go
index 250b26fe76..a145c93d79 100644
--- a/hscontrol/mapper/tail.go
+++ b/hscontrol/mapper/tail.go
@@ -14,16 +14,16 @@ import (
 )
 
 func tailNodes(
-	machines types.Machines,
+	nodes types.Nodes,
 	pol *policy.ACLPolicy,
 	dnsConfig *tailcfg.DNSConfig,
 	baseDomain string,
 ) ([]*tailcfg.Node, error) {
-	nodes := make([]*tailcfg.Node, len(machines))
+	tNodes := make([]*tailcfg.Node, len(nodes))
 
-	for index, machine := range machines {
+	for index, node := range nodes {
 		node, err := tailNode(
-			machine,
+			node,
 			pol,
 			dnsConfig,
 			baseDomain,
@@ -32,37 +32,36 @@ func tailNodes(
 			return nil, err
 		}
 
-		nodes[index] = node
+		tNodes[index] = node
 	}
 
-	return nodes, nil
+	return tNodes, nil
 }
 
-// tailNode converts a Machine into a Tailscale Node. includeRoutes is false for shared nodes
+// tailNode converts a Node into a Tailscale Node. includeRoutes is false for shared nodes
 // as per the expected behaviour in the official SaaS.
 func tailNode(
-	machine *types.Machine,
+	node *types.Node,
 	pol *policy.ACLPolicy,
 	dnsConfig *tailcfg.DNSConfig,
 	baseDomain string,
 ) (*tailcfg.Node, error) {
-	nodeKey, err := machine.NodePublicKey()
+	nodeKey, err := node.NodePublicKey()
 	if err != nil {
 		return nil, err
 	}
 
-	// MachineKey is only used in the legacy protocol
-	machineKey, err := machine.MachinePublicKey()
+	machineKey, err := node.MachinePublicKey()
 	if err != nil {
 		return nil, err
 	}
 
-	discoKey, err := machine.DiscoPublicKey()
+	discoKey, err := node.DiscoPublicKey()
 	if err != nil {
 		return nil, err
 	}
 
-	addrs := machine.IPAddresses.Prefixes()
+	addrs := node.IPAddresses.Prefixes()
 
 	allowedIPs := append(
 		[]netip.Prefix{},
@@ -70,7 +69,7 @@ func tailNode(
 
 	primaryPrefixes := []netip.Prefix{}
 
-	for _, route := range machine.Routes {
+	for _, route := range node.Routes {
 		if route.Enabled {
 			if route.IsPrimary {
 				allowedIPs = append(allowedIPs, netip.Prefix(route.Prefix))
@@ -82,39 +81,39 @@ func tailNode(
 	}
 
 	var derp string
-	if machine.HostInfo.NetInfo != nil {
-		derp = fmt.Sprintf("127.3.3.40:%d", machine.HostInfo.NetInfo.PreferredDERP)
+	if node.HostInfo.NetInfo != nil {
+		derp = fmt.Sprintf("127.3.3.40:%d", node.HostInfo.NetInfo.PreferredDERP)
 	} else {
 		derp = "127.3.3.40:0" // Zero means disconnected or unknown.
 	}
 
 	var keyExpiry time.Time
-	if machine.Expiry != nil {
-		keyExpiry = *machine.Expiry
+	if node.Expiry != nil {
+		keyExpiry = *node.Expiry
 	} else {
 		keyExpiry = time.Time{}
 	}
 
-	hostname, err := machine.GetFQDN(dnsConfig, baseDomain)
+	hostname, err := node.GetFQDN(dnsConfig, baseDomain)
 	if err != nil {
 		return nil, err
 	}
 
-	hostInfo := machine.GetHostInfo()
+	hostInfo := node.GetHostInfo()
 
-	online := machine.IsOnline()
+	online := node.IsOnline()
 
-	tags, _ := pol.TagsOfMachine(machine)
-	tags = lo.Uniq(append(tags, machine.ForcedTags...))
+	tags, _ := pol.TagsOfNode(node)
+	tags = lo.Uniq(append(tags, node.ForcedTags...))
 
-	node := tailcfg.Node{
-		ID: tailcfg.NodeID(machine.ID), // this is the actual ID
+	tNode := tailcfg.Node{
+		ID: tailcfg.NodeID(node.ID), // this is the actual ID
 		StableID: tailcfg.StableNodeID(
-			strconv.FormatUint(machine.ID, util.Base10),
+			strconv.FormatUint(node.ID, util.Base10),
 		), // in headscale, unlike tailcontrol server, IDs are permanent
 		Name: hostname,
 
-		User: tailcfg.UserID(machine.UserID),
+		User: tailcfg.UserID(node.UserID),
 
 		Key:       nodeKey,
 		KeyExpiry: keyExpiry,
@@ -123,19 +122,19 @@ func tailNode(
 		DiscoKey:   discoKey,
 		Addresses:  addrs,
 		AllowedIPs: allowedIPs,
-		Endpoints:  machine.Endpoints,
+		Endpoints:  node.Endpoints,
 		DERP:       derp,
 		Hostinfo:   hostInfo.View(),
-		Created:    machine.CreatedAt,
+		Created:    node.CreatedAt,
 
 		Tags: tags,
 
 		PrimaryRoutes: primaryPrefixes,
 
-		LastSeen:          machine.LastSeen,
+		LastSeen:          node.LastSeen,
 		Online:            &online,
 		KeepAlive:         true,
-		MachineAuthorized: !machine.IsExpired(),
+		MachineAuthorized: !node.IsExpired(),
 
 		Capabilities: []string{
 			tailcfg.CapabilityFileSharing,
@@ -144,5 +143,5 @@ func tailNode(
 		},
 	}
 
-	return &node, nil
+	return &tNode, nil
 }
diff --git a/hscontrol/mapper/tail_test.go b/hscontrol/mapper/tail_test.go
index 28bc8e6585..13d025c186 100644
--- a/hscontrol/mapper/tail_test.go
+++ b/hscontrol/mapper/tail_test.go
@@ -45,7 +45,7 @@ func TestTailNode(t *testing.T) {
 
 	tests := []struct {
 		name       string
-		machine    *types.Machine
+		node       *types.Node
 		pol        *policy.ACLPolicy
 		dnsConfig  *tailcfg.DNSConfig
 		baseDomain string
@@ -53,8 +53,8 @@ func TestTailNode(t *testing.T) {
 		wantErr    bool
 	}{
 		{
-			name:       "empty-machine",
-			machine:    &types.Machine{},
+			name:       "empty-node",
+			node:       &types.Node{},
 			pol:        &policy.ACLPolicy{},
 			dnsConfig:  &tailcfg.DNSConfig{},
 			baseDomain: "",
@@ -62,8 +62,8 @@ func TestTailNode(t *testing.T) {
 			wantErr:    true,
 		},
 		{
-			name: "minimal-machine",
-			machine: &types.Machine{
+			name: "minimal-node",
+			node: &types.Node{
 				ID:         0,
 				MachineKey: "mkey:f08305b4ee4250b95a70f3b7504d048d75d899993c624a26d422c67af0422507",
 				NodeKey:    "nodekey:9b2ffa7e08cc421a3d2cca9012280f6a236fd0de0b4ce005b30a98ad930306fe",
@@ -165,7 +165,7 @@ func TestTailNode(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			got, err := tailNode(
-				tt.machine,
+				tt.node,
 				tt.pol,
 				tt.dnsConfig,
 				tt.baseDomain,
diff --git a/hscontrol/metrics.go b/hscontrol/metrics.go
index 724464c4df..fc56f58414 100644
--- a/hscontrol/metrics.go
+++ b/hscontrol/metrics.go
@@ -8,18 +8,18 @@ import (
 const prometheusNamespace = "headscale"
 
 var (
-	// This is a high cardinality metric (user x machines), we might want to make this
+	// This is a high cardinality metric (user x node), we might want to make this
 	// configurable/opt-in in the future.
-	machineRegistrations = promauto.NewCounterVec(prometheus.CounterOpts{
+	nodeRegistrations = promauto.NewCounterVec(prometheus.CounterOpts{
 		Namespace: prometheusNamespace,
-		Name:      "machine_registrations_total",
-		Help:      "The total amount of registered machine attempts",
+		Name:      "node_registrations_total",
+		Help:      "The total amount of registered node attempts",
 	}, []string{"action", "auth", "status", "user"})
 
 	updateRequestsSentToNode = promauto.NewCounterVec(prometheus.CounterOpts{
 		Namespace: prometheusNamespace,
 		Name:      "update_request_sent_to_node_total",
 		Help:      "The number of calls/messages issued on a specific nodes update channel",
-	}, []string{"user", "machine", "status"})
+	}, []string{"user", "node", "status"})
 	// TODO(kradalby): This is very debugging, we might want to remove it.
 )
diff --git a/hscontrol/oidc.go b/hscontrol/oidc.go
index 010bcb15c5..b32d75133a 100644
--- a/hscontrol/oidc.go
+++ b/hscontrol/oidc.go
@@ -37,8 +37,8 @@ var (
 	errOIDCAllowedUsers  = errors.New(
 		"authenticated principal does not match any allowed user",
 	)
-	errOIDCInvalidMachineState = errors.New(
-		"requested machine state key expired before authorisation completed",
+	errOIDCInvalidNodeState = errors.New(
+		"requested node state key expired before authorisation completed",
 	)
 	errOIDCNodeKeyMissing = errors.New("could not get node key from cache")
 )
@@ -184,9 +184,9 @@ var oidcCallbackTemplate = template.Must(
 )
 
 // OIDCCallback handles the callback from the OIDC endpoint
-// Retrieves the nkey from the state cache and adds the machine to the users email user
-// TODO: A confirmation page for new machines should be added to avoid phishing vulnerabilities
-// TODO: Add groups information from OIDC tokens into machine HostInfo
+// Retrieves the nkey from the state cache and adds the node to the users email user
+// TODO: A confirmation page for new nodes should be added to avoid phishing vulnerabilities
+// TODO: Add groups information from OIDC tokens into node HostInfo
 // Listens in /oidc/callback.
 func (h *Headscale) OIDCCallback(
 	writer http.ResponseWriter,
@@ -232,13 +232,13 @@ func (h *Headscale) OIDCCallback(
 		return
 	}
 
-	nodeKey, machineExists, err := h.validateMachineForOIDCCallback(
+	nodeKey, nodeExists, err := h.validateNodeForOIDCCallback(
 		writer,
 		state,
 		claims,
 		idTokenExpiry,
 	)
-	if err != nil || machineExists {
+	if err != nil || nodeExists {
 		return
 	}
 
@@ -247,15 +247,15 @@ func (h *Headscale) OIDCCallback(
 		return
 	}
 
-	// register the machine if it's new
-	log.Debug().Msg("Registering new machine after successful callback")
+	// register the node if it's new
+	log.Debug().Msg("Registering new node after successful callback")
 
 	user, err := h.findOrCreateNewUserForOIDCCallback(writer, userName)
 	if err != nil {
 		return
 	}
 
-	if err := h.registerMachineForOIDCCallback(writer, user, nodeKey, idTokenExpiry); err != nil {
+	if err := h.registerNodeForOIDCCallback(writer, user, nodeKey, idTokenExpiry); err != nil {
 		return
 	}
 
@@ -453,21 +453,21 @@ func validateOIDCAllowedUsers(
 	return nil
 }
 
-// validateMachine retrieves machine information if it exist
+// validateNode retrieves node information if it exist
 // The error is not important, because if it does not
-// exist, then this is a new machine and we will move
+// exist, then this is a new node and we will move
 // on to registration.
-func (h *Headscale) validateMachineForOIDCCallback(
+func (h *Headscale) validateNodeForOIDCCallback(
 	writer http.ResponseWriter,
 	state string,
 	claims *IDTokenClaims,
 	expiry time.Time,
 ) (*key.NodePublic, bool, error) {
-	// retrieve machinekey from state cache
+	// retrieve nodekey from state cache
 	nodeKeyIf, nodeKeyFound := h.registrationCache.Get(state)
 	if !nodeKeyFound {
 		log.Trace().
-			Msg("requested machine state key expired before authorisation completed")
+			Msg("requested node state key expired before authorisation completed")
 		writer.Header().Set("Content-Type", "text/plain; charset=utf-8")
 		writer.WriteHeader(http.StatusBadRequest)
 		_, err := writer.Write([]byte("state has expired"))
@@ -482,7 +482,7 @@ func (h *Headscale) validateMachineForOIDCCallback(
 	nodeKeyFromCache, nodeKeyOK := nodeKeyIf.(string)
 	if !nodeKeyOK {
 		log.Trace().
-			Msg("requested machine state key is not a string")
+			Msg("requested node state key is not a string")
 		writer.Header().Set("Content-Type", "text/plain; charset=utf-8")
 		writer.WriteHeader(http.StatusBadRequest)
 		_, err := writer.Write([]byte("state is invalid"))
@@ -490,7 +490,7 @@ func (h *Headscale) validateMachineForOIDCCallback(
 			util.LogErr(err, "Failed to write response")
 		}
 
-		return nil, false, errOIDCInvalidMachineState
+		return nil, false, errOIDCInvalidNodeState
 	}
 
 	err := nodeKey.UnmarshalText(
@@ -511,33 +511,33 @@ func (h *Headscale) validateMachineForOIDCCallback(
 		return nil, false, err
 	}
 
-	// retrieve machine information if it exist
+	// retrieve node information if it exist
 	// The error is not important, because if it does not
-	// exist, then this is a new machine and we will move
+	// exist, then this is a new node and we will move
 	// on to registration.
-	machine, _ := h.db.GetMachineByNodeKey(nodeKey)
+	node, _ := h.db.GetNodeByNodeKey(nodeKey)
 
-	if machine != nil {
+	if node != nil {
 		log.Trace().
 			Caller().
-			Str("machine", machine.Hostname).
-			Msg("machine already registered, reauthenticating")
+			Str("node", node.Hostname).
+			Msg("node already registered, reauthenticating")
 
-		err := h.db.MachineSetExpiry(machine, expiry)
+		err := h.db.NodeSetExpiry(node, expiry)
 		if err != nil {
-			util.LogErr(err, "Failed to refresh machine")
+			util.LogErr(err, "Failed to refresh node")
 			http.Error(
 				writer,
-				"Failed to refresh machine",
+				"Failed to refresh node",
 				http.StatusInternalServerError,
 			)
 
 			return nil, true, err
 		}
 		log.Debug().
-			Str("machine", machine.Hostname).
+			Str("node", node.Hostname).
 			Str("expiresAt", fmt.Sprintf("%v", expiry)).
-			Msg("successfully refreshed machine")
+			Msg("successfully refreshed node")
 
 		var content bytes.Buffer
 		if err := oidcCallbackTemplate.Execute(&content, oidcCallbackTemplateConfig{
@@ -638,13 +638,13 @@ func (h *Headscale) findOrCreateNewUserForOIDCCallback(
 	return user, nil
 }
 
-func (h *Headscale) registerMachineForOIDCCallback(
+func (h *Headscale) registerNodeForOIDCCallback(
 	writer http.ResponseWriter,
 	user *types.User,
 	nodeKey *key.NodePublic,
 	expiry time.Time,
 ) error {
-	if _, err := h.db.RegisterMachineFromAuthCallback(
+	if _, err := h.db.RegisterNodeFromAuthCallback(
 		// TODO(kradalby): find a better way to use the cache across modules
 		h.registrationCache,
 		nodeKey.String(),
@@ -652,10 +652,10 @@ func (h *Headscale) registerMachineForOIDCCallback(
 		&expiry,
 		util.RegisterMethodOIDC,
 	); err != nil {
-		util.LogErr(err, "could not register machine")
+		util.LogErr(err, "could not register node")
 		writer.Header().Set("Content-Type", "text/plain; charset=utf-8")
 		writer.WriteHeader(http.StatusInternalServerError)
-		_, werr := writer.Write([]byte("could not register machine"))
+		_, werr := writer.Write([]byte("could not register node"))
 		if werr != nil {
 			util.LogErr(err, "Failed to write response")
 		}
diff --git a/hscontrol/policy/acls.go b/hscontrol/policy/acls.go
index 90befd55eb..08ce800c7d 100644
--- a/hscontrol/policy/acls.go
+++ b/hscontrol/policy/acls.go
@@ -116,30 +116,30 @@ func LoadACLPolicyFromBytes(acl []byte, format string) (*ACLPolicy, error) {
 
 func GenerateFilterAndSSHRules(
 	policy *ACLPolicy,
-	machine *types.Machine,
-	peers types.Machines,
+	node *types.Node,
+	peers types.Nodes,
 ) ([]tailcfg.FilterRule, *tailcfg.SSHPolicy, error) {
 	// If there is no policy defined, we default to allow all
 	if policy == nil {
 		return tailcfg.FilterAllowAll, &tailcfg.SSHPolicy{}, nil
 	}
 
-	rules, err := policy.generateFilterRules(machine, peers)
+	rules, err := policy.generateFilterRules(node, peers)
 	if err != nil {
 		return []tailcfg.FilterRule{}, &tailcfg.SSHPolicy{}, err
 	}
 
-	log.Trace().Interface("ACL", rules).Str("machine", machine.GivenName).Msg("ACL rules")
+	log.Trace().Interface("ACL", rules).Str("node", node.GivenName).Msg("ACL rules")
 
 	var sshPolicy *tailcfg.SSHPolicy
-	sshRules, err := policy.generateSSHRules(machine, peers)
+	sshRules, err := policy.generateSSHRules(node, peers)
 	if err != nil {
 		return []tailcfg.FilterRule{}, &tailcfg.SSHPolicy{}, err
 	}
 
 	log.Trace().
 		Interface("SSH", sshRules).
-		Str("machine", machine.GivenName).
+		Str("node", node.GivenName).
 		Msg("SSH rules")
 
 	if sshPolicy == nil {
@@ -150,14 +150,14 @@ func GenerateFilterAndSSHRules(
 	return rules, sshPolicy, nil
 }
 
-// generateFilterRules takes a set of machines and an ACLPolicy and generates a
+// generateFilterRules takes a set of nodes and an ACLPolicy and generates a
 // set of Tailscale compatible FilterRules used to allow traffic on clients.
 func (pol *ACLPolicy) generateFilterRules(
-	machine *types.Machine,
-	peers types.Machines,
+	node *types.Node,
+	peers types.Nodes,
 ) ([]tailcfg.FilterRule, error) {
 	rules := []tailcfg.FilterRule{}
-	machines := append(peers, machine)
+	nodes := append(peers, node)
 
 	for index, acl := range pol.ACLs {
 		if acl.Action != "accept" {
@@ -166,7 +166,7 @@ func (pol *ACLPolicy) generateFilterRules(
 
 		srcIPs := []string{}
 		for srcIndex, src := range acl.Sources {
-			srcs, err := pol.expandSource(src, machines)
+			srcs, err := pol.expandSource(src, nodes)
 			if err != nil {
 				log.Error().
 					Interface("src", src).
@@ -195,7 +195,7 @@ func (pol *ACLPolicy) generateFilterRules(
 			}
 
 			expanded, err := pol.ExpandAlias(
-				machines,
+				nodes,
 				alias,
 			)
 			if err != nil {
@@ -230,13 +230,13 @@ func (pol *ACLPolicy) generateFilterRules(
 	return rules, nil
 }
 
-// ReduceFilterRules takes a machine and a set of rules and removes all rules and destinations
+// ReduceFilterRules takes a node and a set of rules and removes all rules and destinations
 // that are not relevant to that particular node.
-func ReduceFilterRules(machine *types.Machine, rules []tailcfg.FilterRule) []tailcfg.FilterRule {
+func ReduceFilterRules(node *types.Node, rules []tailcfg.FilterRule) []tailcfg.FilterRule {
 	ret := []tailcfg.FilterRule{}
 
 	for _, rule := range rules {
-		// record if the rule is actually relevant for the given machine.
+		// record if the rule is actually relevant for the given node.
 		dests := []tailcfg.NetPortRange{}
 
 		for _, dest := range rule.DstPorts {
@@ -247,7 +247,7 @@ func ReduceFilterRules(machine *types.Machine, rules []tailcfg.FilterRule) []tai
 				continue
 			}
 
-			if machine.IPAddresses.InIPSet(expanded) {
+			if node.IPAddresses.InIPSet(expanded) {
 				dests = append(dests, dest)
 			}
 		}
@@ -265,8 +265,8 @@ func ReduceFilterRules(machine *types.Machine, rules []tailcfg.FilterRule) []tai
 }
 
 func (pol *ACLPolicy) generateSSHRules(
-	machine *types.Machine,
-	peers types.Machines,
+	node *types.Node,
+	peers types.Nodes,
 ) ([]*tailcfg.SSHRule, error) {
 	rules := []*tailcfg.SSHRule{}
 
@@ -293,7 +293,7 @@ func (pol *ACLPolicy) generateSSHRules(
 	for index, sshACL := range pol.SSHs {
 		var dest netipx.IPSetBuilder
 		for _, src := range sshACL.Destinations {
-			expanded, err := pol.ExpandAlias(append(peers, machine), src)
+			expanded, err := pol.ExpandAlias(append(peers, node), src)
 			if err != nil {
 				return nil, err
 			}
@@ -305,7 +305,7 @@ func (pol *ACLPolicy) generateSSHRules(
 			return nil, err
 		}
 
-		if !machine.IPAddresses.InIPSet(destSet) {
+		if !node.IPAddresses.InIPSet(destSet) {
 			continue
 		}
 
@@ -501,9 +501,9 @@ func parseProtocol(protocol string) ([]int, bool, error) {
 // with the given src alias.
 func (pol *ACLPolicy) expandSource(
 	src string,
-	machines types.Machines,
+	nodes types.Nodes,
 ) ([]string, error) {
-	ipSet, err := pol.ExpandAlias(machines, src)
+	ipSet, err := pol.ExpandAlias(nodes, src)
 	if err != nil {
 		return []string{}, err
 	}
@@ -526,7 +526,7 @@ func (pol *ACLPolicy) expandSource(
 // - a cidr
 // and transform these in IPAddresses.
 func (pol *ACLPolicy) ExpandAlias(
-	machines types.Machines,
+	nodes types.Nodes,
 	alias string,
 ) (*netipx.IPSet, error) {
 	if isWildcard(alias) {
@@ -541,16 +541,16 @@ func (pol *ACLPolicy) ExpandAlias(
 
 	// if alias is a group
 	if isGroup(alias) {
-		return pol.expandIPsFromGroup(alias, machines)
+		return pol.expandIPsFromGroup(alias, nodes)
 	}
 
 	// if alias is a tag
 	if isTag(alias) {
-		return pol.expandIPsFromTag(alias, machines)
+		return pol.expandIPsFromTag(alias, nodes)
 	}
 
 	// if alias is a user
-	if ips, err := pol.expandIPsFromUser(alias, machines); ips != nil {
+	if ips, err := pol.expandIPsFromUser(alias, nodes); ips != nil {
 		return ips, err
 	}
 
@@ -559,17 +559,17 @@ func (pol *ACLPolicy) ExpandAlias(
 	if h, ok := pol.Hosts[alias]; ok {
 		log.Trace().Str("host", h.String()).Msg("ExpandAlias got hosts entry")
 
-		return pol.ExpandAlias(machines, h.String())
+		return pol.ExpandAlias(nodes, h.String())
 	}
 
 	// if alias is an IP
 	if ip, err := netip.ParseAddr(alias); err == nil {
-		return pol.expandIPsFromSingleIP(ip, machines)
+		return pol.expandIPsFromSingleIP(ip, nodes)
 	}
 
 	// if alias is an IP Prefix (CIDR)
 	if prefix, err := netip.ParsePrefix(alias); err == nil {
-		return pol.expandIPsFromIPPrefix(prefix, machines)
+		return pol.expandIPsFromIPPrefix(prefix, nodes)
 	}
 
 	log.Warn().Msgf("No IPs found with the alias %v", alias)
@@ -582,10 +582,10 @@ func (pol *ACLPolicy) ExpandAlias(
 // we assume in this function that we only have nodes from 1 user.
 func excludeCorrectlyTaggedNodes(
 	aclPolicy *ACLPolicy,
-	nodes types.Machines,
+	nodes types.Nodes,
 	user string,
-) types.Machines {
-	out := types.Machines{}
+) types.Nodes {
+	out := types.Nodes{}
 	tags := []string{}
 	for tag := range aclPolicy.TagOwners {
 		owners, _ := expandOwnersFromTag(aclPolicy, user)
@@ -594,9 +594,9 @@ func excludeCorrectlyTaggedNodes(
 			tags = append(tags, tag)
 		}
 	}
-	// for each machine if tag is in tags list, don't append it.
-	for _, machine := range nodes {
-		hi := machine.GetHostInfo()
+	// for each node if tag is in tags list, don't append it.
+	for _, node := range nodes {
+		hi := node.GetHostInfo()
 
 		found := false
 		for _, t := range hi.RequestTags {
@@ -606,11 +606,11 @@ func excludeCorrectlyTaggedNodes(
 				break
 			}
 		}
-		if len(machine.ForcedTags) > 0 {
+		if len(node.ForcedTags) > 0 {
 			found = true
 		}
 		if !found {
-			out = append(out, machine)
+			out = append(out, node)
 		}
 	}
 
@@ -733,7 +733,7 @@ func (pol *ACLPolicy) expandUsersFromGroup(
 
 func (pol *ACLPolicy) expandIPsFromGroup(
 	group string,
-	machines types.Machines,
+	nodes types.Nodes,
 ) (*netipx.IPSet, error) {
 	build := netipx.IPSetBuilder{}
 
@@ -742,9 +742,9 @@ func (pol *ACLPolicy) expandIPsFromGroup(
 		return &netipx.IPSet{}, err
 	}
 	for _, user := range users {
-		filteredMachines := filterMachinesByUser(machines, user)
-		for _, machine := range filteredMachines {
-			machine.IPAddresses.AppendToIPSet(&build)
+		filteredNodes := filterNodesByUser(nodes, user)
+		for _, node := range filteredNodes {
+			node.IPAddresses.AppendToIPSet(&build)
 		}
 	}
 
@@ -753,14 +753,14 @@ func (pol *ACLPolicy) expandIPsFromGroup(
 
 func (pol *ACLPolicy) expandIPsFromTag(
 	alias string,
-	machines types.Machines,
+	nodes types.Nodes,
 ) (*netipx.IPSet, error) {
 	build := netipx.IPSetBuilder{}
 
 	// check for forced tags
-	for _, machine := range machines {
-		if util.StringOrPrefixListContains(machine.ForcedTags, alias) {
-			machine.IPAddresses.AppendToIPSet(&build)
+	for _, node := range nodes {
+		if util.StringOrPrefixListContains(node.ForcedTags, alias) {
+			node.IPAddresses.AppendToIPSet(&build)
 		}
 	}
 
@@ -783,13 +783,13 @@ func (pol *ACLPolicy) expandIPsFromTag(
 		}
 	}
 
-	// filter out machines per tag owner
+	// filter out nodes per tag owner
 	for _, user := range owners {
-		machines := filterMachinesByUser(machines, user)
-		for _, machine := range machines {
-			hi := machine.GetHostInfo()
+		nodes := filterNodesByUser(nodes, user)
+		for _, node := range nodes {
+			hi := node.GetHostInfo()
 			if util.StringOrPrefixListContains(hi.RequestTags, alias) {
-				machine.IPAddresses.AppendToIPSet(&build)
+				node.IPAddresses.AppendToIPSet(&build)
 			}
 		}
 	}
@@ -799,20 +799,20 @@ func (pol *ACLPolicy) expandIPsFromTag(
 
 func (pol *ACLPolicy) expandIPsFromUser(
 	user string,
-	machines types.Machines,
+	nodes types.Nodes,
 ) (*netipx.IPSet, error) {
 	build := netipx.IPSetBuilder{}
 
-	filteredMachines := filterMachinesByUser(machines, user)
-	filteredMachines = excludeCorrectlyTaggedNodes(pol, filteredMachines, user)
+	filteredNodes := filterNodesByUser(nodes, user)
+	filteredNodes = excludeCorrectlyTaggedNodes(pol, filteredNodes, user)
 
-	// shortcurcuit if we have no machines to get ips from.
-	if len(filteredMachines) == 0 {
+	// shortcurcuit if we have no nodes to get ips from.
+	if len(filteredNodes) == 0 {
 		return nil, nil //nolint
 	}
 
-	for _, machine := range filteredMachines {
-		machine.IPAddresses.AppendToIPSet(&build)
+	for _, node := range filteredNodes {
+		node.IPAddresses.AppendToIPSet(&build)
 	}
 
 	return build.IPSet()
@@ -820,17 +820,17 @@ func (pol *ACLPolicy) expandIPsFromUser(
 
 func (pol *ACLPolicy) expandIPsFromSingleIP(
 	ip netip.Addr,
-	machines types.Machines,
+	nodes types.Nodes,
 ) (*netipx.IPSet, error) {
 	log.Trace().Str("ip", ip.String()).Msg("ExpandAlias got ip")
 
-	matches := machines.FilterByIP(ip)
+	matches := nodes.FilterByIP(ip)
 
 	build := netipx.IPSetBuilder{}
 	build.Add(ip)
 
-	for _, machine := range matches {
-		machine.IPAddresses.AppendToIPSet(&build)
+	for _, node := range matches {
+		node.IPAddresses.AppendToIPSet(&build)
 	}
 
 	return build.IPSet()
@@ -838,7 +838,7 @@ func (pol *ACLPolicy) expandIPsFromSingleIP(
 
 func (pol *ACLPolicy) expandIPsFromIPPrefix(
 	prefix netip.Prefix,
-	machines types.Machines,
+	nodes types.Nodes,
 ) (*netipx.IPSet, error) {
 	log.Trace().Str("prefix", prefix.String()).Msg("expandAlias got prefix")
 	build := netipx.IPSetBuilder{}
@@ -846,12 +846,12 @@ func (pol *ACLPolicy) expandIPsFromIPPrefix(
 
 	// This is suboptimal and quite expensive, but if we only add the prefix, we will miss all the relevant IPv6
 	// addresses for the hosts that belong to tailscale. This doesnt really affect stuff like subnet routers.
-	for _, machine := range machines {
-		for _, ip := range machine.IPAddresses {
+	for _, node := range nodes {
+		for _, ip := range node.IPAddresses {
 			// log.Trace().
-			// 	Msgf("checking if machine ip (%s) is part of prefix (%s): %v, is single ip prefix (%v), addr: %s", ip.String(), prefix.String(), prefix.Contains(ip), prefix.IsSingleIP(), prefix.Addr().String())
+			// 	Msgf("checking if node ip (%s) is part of prefix (%s): %v, is single ip prefix (%v), addr: %s", ip.String(), prefix.String(), prefix.Contains(ip), prefix.IsSingleIP(), prefix.Addr().String())
 			if prefix.Contains(ip) {
-				machine.IPAddresses.AppendToIPSet(&build)
+				node.IPAddresses.AppendToIPSet(&build)
 			}
 		}
 	}
@@ -871,18 +871,18 @@ func isTag(str string) bool {
 	return strings.HasPrefix(str, "tag:")
 }
 
-// TagsOfMachine will return the tags of the current machine.
+// TagsOfNode will return the tags of the current node.
 // Invalid tags are tags added by a user on a node, and that user doesn't have authority to add this tag.
 // Valid tags are tags added by a user that is allowed in the ACL policy to add this tag.
-func (pol *ACLPolicy) TagsOfMachine(
-	machine *types.Machine,
+func (pol *ACLPolicy) TagsOfNode(
+	node *types.Node,
 ) ([]string, []string) {
 	validTags := make([]string, 0)
 	invalidTags := make([]string, 0)
 
 	validTagMap := make(map[string]bool)
 	invalidTagMap := make(map[string]bool)
-	for _, tag := range machine.HostInfo.RequestTags {
+	for _, tag := range node.HostInfo.RequestTags {
 		owners, err := expandOwnersFromTag(pol, tag)
 		if errors.Is(err, ErrInvalidTag) {
 			invalidTagMap[tag] = true
@@ -891,7 +891,7 @@ func (pol *ACLPolicy) TagsOfMachine(
 		}
 		var found bool
 		for _, owner := range owners {
-			if machine.User.Name == owner {
+			if node.User.Name == owner {
 				found = true
 			}
 		}
@@ -911,31 +911,31 @@ func (pol *ACLPolicy) TagsOfMachine(
 	return validTags, invalidTags
 }
 
-func filterMachinesByUser(machines types.Machines, user string) types.Machines {
-	out := types.Machines{}
-	for _, machine := range machines {
-		if machine.User.Name == user {
-			out = append(out, machine)
+func filterNodesByUser(nodes types.Nodes, user string) types.Nodes {
+	out := types.Nodes{}
+	for _, node := range nodes {
+		if node.User.Name == user {
+			out = append(out, node)
 		}
 	}
 
 	return out
 }
 
-// FilterMachinesByACL returns the list of peers authorized to be accessed from a given machine.
-func FilterMachinesByACL(
-	machine *types.Machine,
-	machines types.Machines,
+// FilterNodesByACL returns the list of peers authorized to be accessed from a given node.
+func FilterNodesByACL(
+	node *types.Node,
+	nodes types.Nodes,
 	filter []tailcfg.FilterRule,
-) types.Machines {
-	result := types.Machines{}
+) types.Nodes {
+	result := types.Nodes{}
 
-	for index, peer := range machines {
-		if peer.ID == machine.ID {
+	for index, peer := range nodes {
+		if peer.ID == node.ID {
 			continue
 		}
 
-		if machine.CanAccess(filter, machines[index]) || peer.CanAccess(filter, machine) {
+		if node.CanAccess(filter, nodes[index]) || peer.CanAccess(filter, node) {
 			result = append(result, peer)
 		}
 	}
diff --git a/hscontrol/policy/acls_test.go b/hscontrol/policy/acls_test.go
index 9afb58a546..b2d694bbc3 100644
--- a/hscontrol/policy/acls_test.go
+++ b/hscontrol/policy/acls_test.go
@@ -389,13 +389,13 @@ acls:
 				return
 			}
 
-			rules, err := pol.generateFilterRules(&types.Machine{
-				IPAddresses: types.MachineAddresses{
+			rules, err := pol.generateFilterRules(&types.Node{
+				IPAddresses: types.NodeAddresses{
 					netip.MustParseAddr("100.100.100.100"),
 				},
-			}, types.Machines{
-				&types.Machine{
-					IPAddresses: types.MachineAddresses{
+			}, types.Nodes{
+				&types.Node{
+					IPAddresses: types.NodeAddresses{
 						netip.MustParseAddr("200.200.200.200"),
 					},
 					User: types.User{
@@ -549,7 +549,7 @@ func (s *Suite) TestRuleInvalidGeneration(c *check.C) {
 	c.Assert(pol.ACLs, check.HasLen, 6)
 	c.Assert(err, check.IsNil)
 
-	rules, err := pol.generateFilterRules(&types.Machine{}, types.Machines{})
+	rules, err := pol.generateFilterRules(&types.Node{}, types.Nodes{})
 	c.Assert(err, check.NotNil)
 	c.Assert(rules, check.IsNil)
 }
@@ -565,7 +565,7 @@ func (s *Suite) TestInvalidAction(c *check.C) {
 			},
 		},
 	}
-	_, _, err := GenerateFilterAndSSHRules(pol, &types.Machine{}, types.Machines{})
+	_, _, err := GenerateFilterAndSSHRules(pol, &types.Node{}, types.Nodes{})
 	c.Assert(errors.Is(err, ErrInvalidAction), check.Equals, true)
 }
 
@@ -584,7 +584,7 @@ func (s *Suite) TestInvalidGroupInGroup(c *check.C) {
 			},
 		},
 	}
-	_, _, err := GenerateFilterAndSSHRules(pol, &types.Machine{}, types.Machines{})
+	_, _, err := GenerateFilterAndSSHRules(pol, &types.Node{}, types.Nodes{})
 	c.Assert(errors.Is(err, ErrInvalidGroup), check.Equals, true)
 }
 
@@ -600,7 +600,7 @@ func (s *Suite) TestInvalidTagOwners(c *check.C) {
 		},
 	}
 
-	_, _, err := GenerateFilterAndSSHRules(pol, &types.Machine{}, types.Machines{})
+	_, _, err := GenerateFilterAndSSHRules(pol, &types.Node{}, types.Nodes{})
 	c.Assert(errors.Is(err, ErrInvalidTag), check.Equals, true)
 }
 
@@ -895,64 +895,64 @@ func Test_expandPorts(t *testing.T) {
 	}
 }
 
-func Test_listMachinesInUser(t *testing.T) {
+func Test_listNodesInUser(t *testing.T) {
 	type args struct {
-		machines types.Machines
-		user     string
+		nodes types.Nodes
+		user  string
 	}
 	tests := []struct {
 		name string
 		args args
-		want types.Machines
+		want types.Nodes
 	}{
 		{
-			name: "1 machine in user",
+			name: "1 node in user",
 			args: args{
-				machines: types.Machines{
-					&types.Machine{User: types.User{Name: "joe"}},
+				nodes: types.Nodes{
+					&types.Node{User: types.User{Name: "joe"}},
 				},
 				user: "joe",
 			},
-			want: types.Machines{
-				&types.Machine{User: types.User{Name: "joe"}},
+			want: types.Nodes{
+				&types.Node{User: types.User{Name: "joe"}},
 			},
 		},
 		{
-			name: "3 machines, 2 in user",
+			name: "3 nodes, 2 in user",
 			args: args{
-				machines: types.Machines{
-					&types.Machine{ID: 1, User: types.User{Name: "joe"}},
-					&types.Machine{ID: 2, User: types.User{Name: "marc"}},
-					&types.Machine{ID: 3, User: types.User{Name: "marc"}},
+				nodes: types.Nodes{
+					&types.Node{ID: 1, User: types.User{Name: "joe"}},
+					&types.Node{ID: 2, User: types.User{Name: "marc"}},
+					&types.Node{ID: 3, User: types.User{Name: "marc"}},
 				},
 				user: "marc",
 			},
-			want: types.Machines{
-				&types.Machine{ID: 2, User: types.User{Name: "marc"}},
-				&types.Machine{ID: 3, User: types.User{Name: "marc"}},
+			want: types.Nodes{
+				&types.Node{ID: 2, User: types.User{Name: "marc"}},
+				&types.Node{ID: 3, User: types.User{Name: "marc"}},
 			},
 		},
 		{
-			name: "5 machines, 0 in user",
+			name: "5 nodes, 0 in user",
 			args: args{
-				machines: types.Machines{
-					&types.Machine{ID: 1, User: types.User{Name: "joe"}},
-					&types.Machine{ID: 2, User: types.User{Name: "marc"}},
-					&types.Machine{ID: 3, User: types.User{Name: "marc"}},
-					&types.Machine{ID: 4, User: types.User{Name: "marc"}},
-					&types.Machine{ID: 5, User: types.User{Name: "marc"}},
+				nodes: types.Nodes{
+					&types.Node{ID: 1, User: types.User{Name: "joe"}},
+					&types.Node{ID: 2, User: types.User{Name: "marc"}},
+					&types.Node{ID: 3, User: types.User{Name: "marc"}},
+					&types.Node{ID: 4, User: types.User{Name: "marc"}},
+					&types.Node{ID: 5, User: types.User{Name: "marc"}},
 				},
 				user: "mickael",
 			},
-			want: types.Machines{},
+			want: types.Nodes{},
 		},
 	}
 	for _, test := range tests {
 		t.Run(test.name, func(t *testing.T) {
-			got := filterMachinesByUser(test.args.machines, test.args.user)
+			got := filterNodesByUser(test.args.nodes, test.args.user)
 
 			if diff := cmp.Diff(test.want, got); diff != "" {
-				t.Errorf("listMachinesInUser() = (-want +got):\n%s", diff)
+				t.Errorf("listNodesInUser() = (-want +got):\n%s", diff)
 			}
 		})
 	}
@@ -979,7 +979,7 @@ func Test_expandAlias(t *testing.T) {
 		pol ACLPolicy
 	}
 	type args struct {
-		machines  types.Machines
+		nodes     types.Nodes
 		aclPolicy ACLPolicy
 		alias     string
 	}
@@ -997,12 +997,12 @@ func Test_expandAlias(t *testing.T) {
 			},
 			args: args{
 				alias: "*",
-				machines: types.Machines{
-					&types.Machine{
-						IPAddresses: types.MachineAddresses{netip.MustParseAddr("100.64.0.1")},
+				nodes: types.Nodes{
+					&types.Node{
+						IPAddresses: types.NodeAddresses{netip.MustParseAddr("100.64.0.1")},
 					},
-					&types.Machine{
-						IPAddresses: types.MachineAddresses{
+					&types.Node{
+						IPAddresses: types.NodeAddresses{
 							netip.MustParseAddr("100.78.84.227"),
 						},
 					},
@@ -1023,27 +1023,27 @@ func Test_expandAlias(t *testing.T) {
 			},
 			args: args{
 				alias: "group:accountant",
-				machines: types.Machines{
-					&types.Machine{
-						IPAddresses: types.MachineAddresses{
+				nodes: types.Nodes{
+					&types.Node{
+						IPAddresses: types.NodeAddresses{
 							netip.MustParseAddr("100.64.0.1"),
 						},
 						User: types.User{Name: "joe"},
 					},
-					&types.Machine{
-						IPAddresses: types.MachineAddresses{
+					&types.Node{
+						IPAddresses: types.NodeAddresses{
 							netip.MustParseAddr("100.64.0.2"),
 						},
 						User: types.User{Name: "joe"},
 					},
-					&types.Machine{
-						IPAddresses: types.MachineAddresses{
+					&types.Node{
+						IPAddresses: types.NodeAddresses{
 							netip.MustParseAddr("100.64.0.3"),
 						},
 						User: types.User{Name: "marc"},
 					},
-					&types.Machine{
-						IPAddresses: types.MachineAddresses{
+					&types.Node{
+						IPAddresses: types.NodeAddresses{
 							netip.MustParseAddr("100.64.0.4"),
 						},
 						User: types.User{Name: "mickael"},
@@ -1064,27 +1064,27 @@ func Test_expandAlias(t *testing.T) {
 			},
 			args: args{
 				alias: "group:hr",
-				machines: types.Machines{
-					&types.Machine{
-						IPAddresses: types.MachineAddresses{
+				nodes: types.Nodes{
+					&types.Node{
+						IPAddresses: types.NodeAddresses{
 							netip.MustParseAddr("100.64.0.1"),
 						},
 						User: types.User{Name: "joe"},
 					},
-					&types.Machine{
-						IPAddresses: types.MachineAddresses{
+					&types.Node{
+						IPAddresses: types.NodeAddresses{
 							netip.MustParseAddr("100.64.0.2"),
 						},
 						User: types.User{Name: "joe"},
 					},
-					&types.Machine{
-						IPAddresses: types.MachineAddresses{
+					&types.Node{
+						IPAddresses: types.NodeAddresses{
 							netip.MustParseAddr("100.64.0.3"),
 						},
 						User: types.User{Name: "marc"},
 					},
-					&types.Machine{
-						IPAddresses: types.MachineAddresses{
+					&types.Node{
+						IPAddresses: types.NodeAddresses{
 							netip.MustParseAddr("100.64.0.4"),
 						},
 						User: types.User{Name: "mickael"},
@@ -1100,8 +1100,8 @@ func Test_expandAlias(t *testing.T) {
 				pol: ACLPolicy{},
 			},
 			args: args{
-				alias:    "10.0.0.3",
-				machines: types.Machines{},
+				alias: "10.0.0.3",
+				nodes: types.Nodes{},
 			},
 			want: set([]string{
 				"10.0.0.3",
@@ -1114,8 +1114,8 @@ func Test_expandAlias(t *testing.T) {
 				pol: ACLPolicy{},
 			},
 			args: args{
-				alias:    "10.0.0.1",
-				machines: types.Machines{},
+				alias: "10.0.0.1",
+				nodes: types.Nodes{},
 			},
 			want: set([]string{
 				"10.0.0.1",
@@ -1129,9 +1129,9 @@ func Test_expandAlias(t *testing.T) {
 			},
 			args: args{
 				alias: "10.0.0.1",
-				machines: types.Machines{
-					&types.Machine{
-						IPAddresses: types.MachineAddresses{
+				nodes: types.Nodes{
+					&types.Node{
+						IPAddresses: types.NodeAddresses{
 							netip.MustParseAddr("10.0.0.1"),
 						},
 						User: types.User{Name: "mickael"},
@@ -1150,9 +1150,9 @@ func Test_expandAlias(t *testing.T) {
 			},
 			args: args{
 				alias: "10.0.0.1",
-				machines: types.Machines{
-					&types.Machine{
-						IPAddresses: types.MachineAddresses{
+				nodes: types.Nodes{
+					&types.Node{
+						IPAddresses: types.NodeAddresses{
 							netip.MustParseAddr("10.0.0.1"),
 							netip.MustParseAddr("fd7a:115c:a1e0:ab12:4843:2222:6273:2222"),
 						},
@@ -1172,9 +1172,9 @@ func Test_expandAlias(t *testing.T) {
 			},
 			args: args{
 				alias: "fd7a:115c:a1e0:ab12:4843:2222:6273:2222",
-				machines: types.Machines{
-					&types.Machine{
-						IPAddresses: types.MachineAddresses{
+				nodes: types.Nodes{
+					&types.Node{
+						IPAddresses: types.NodeAddresses{
 							netip.MustParseAddr("10.0.0.1"),
 							netip.MustParseAddr("fd7a:115c:a1e0:ab12:4843:2222:6273:2222"),
 						},
@@ -1197,8 +1197,8 @@ func Test_expandAlias(t *testing.T) {
 				},
 			},
 			args: args{
-				alias:    "testy",
-				machines: types.Machines{},
+				alias: "testy",
+				nodes: types.Nodes{},
 			},
 			want:    set([]string{}, []string{"10.0.0.132/32"}),
 			wantErr: false,
@@ -1213,8 +1213,8 @@ func Test_expandAlias(t *testing.T) {
 				},
 			},
 			args: args{
-				alias:    "homeNetwork",
-				machines: types.Machines{},
+				alias: "homeNetwork",
+				nodes: types.Nodes{},
 			},
 			want:    set([]string{}, []string{"192.168.1.0/24"}),
 			wantErr: false,
@@ -1226,7 +1226,7 @@ func Test_expandAlias(t *testing.T) {
 			},
 			args: args{
 				alias:     "10.0.0.0/16",
-				machines:  types.Machines{},
+				nodes:     types.Nodes{},
 				aclPolicy: ACLPolicy{},
 			},
 			want:    set([]string{}, []string{"10.0.0.0/16"}),
@@ -1241,9 +1241,9 @@ func Test_expandAlias(t *testing.T) {
 			},
 			args: args{
 				alias: "tag:hr-webserver",
-				machines: types.Machines{
-					&types.Machine{
-						IPAddresses: types.MachineAddresses{
+				nodes: types.Nodes{
+					&types.Node{
+						IPAddresses: types.NodeAddresses{
 							netip.MustParseAddr("100.64.0.1"),
 						},
 						User: types.User{Name: "joe"},
@@ -1253,8 +1253,8 @@ func Test_expandAlias(t *testing.T) {
 							RequestTags: []string{"tag:hr-webserver"},
 						},
 					},
-					&types.Machine{
-						IPAddresses: types.MachineAddresses{
+					&types.Node{
+						IPAddresses: types.NodeAddresses{
 							netip.MustParseAddr("100.64.0.2"),
 						},
 						User: types.User{Name: "joe"},
@@ -1264,14 +1264,14 @@ func Test_expandAlias(t *testing.T) {
 							RequestTags: []string{"tag:hr-webserver"},
 						},
 					},
-					&types.Machine{
-						IPAddresses: types.MachineAddresses{
+					&types.Node{
+						IPAddresses: types.NodeAddresses{
 							netip.MustParseAddr("100.64.0.3"),
 						},
 						User: types.User{Name: "marc"},
 					},
-					&types.Machine{
-						IPAddresses: types.MachineAddresses{
+					&types.Node{
+						IPAddresses: types.NodeAddresses{
 							netip.MustParseAddr("100.64.0.4"),
 						},
 						User: types.User{Name: "joe"},
@@ -1295,27 +1295,27 @@ func Test_expandAlias(t *testing.T) {
 			},
 			args: args{
 				alias: "tag:hr-webserver",
-				machines: types.Machines{
-					&types.Machine{
-						IPAddresses: types.MachineAddresses{
+				nodes: types.Nodes{
+					&types.Node{
+						IPAddresses: types.NodeAddresses{
 							netip.MustParseAddr("100.64.0.1"),
 						},
 						User: types.User{Name: "joe"},
 					},
-					&types.Machine{
-						IPAddresses: types.MachineAddresses{
+					&types.Node{
+						IPAddresses: types.NodeAddresses{
 							netip.MustParseAddr("100.64.0.2"),
 						},
 						User: types.User{Name: "joe"},
 					},
-					&types.Machine{
-						IPAddresses: types.MachineAddresses{
+					&types.Node{
+						IPAddresses: types.NodeAddresses{
 							netip.MustParseAddr("100.64.0.3"),
 						},
 						User: types.User{Name: "marc"},
 					},
-					&types.Machine{
-						IPAddresses: types.MachineAddresses{
+					&types.Node{
+						IPAddresses: types.NodeAddresses{
 							netip.MustParseAddr("100.64.0.4"),
 						},
 						User: types.User{Name: "mickael"},
@@ -1332,29 +1332,29 @@ func Test_expandAlias(t *testing.T) {
 			},
 			args: args{
 				alias: "tag:hr-webserver",
-				machines: types.Machines{
-					&types.Machine{
-						IPAddresses: types.MachineAddresses{
+				nodes: types.Nodes{
+					&types.Node{
+						IPAddresses: types.NodeAddresses{
 							netip.MustParseAddr("100.64.0.1"),
 						},
 						User:       types.User{Name: "joe"},
 						ForcedTags: []string{"tag:hr-webserver"},
 					},
-					&types.Machine{
-						IPAddresses: types.MachineAddresses{
+					&types.Node{
+						IPAddresses: types.NodeAddresses{
 							netip.MustParseAddr("100.64.0.2"),
 						},
 						User:       types.User{Name: "joe"},
 						ForcedTags: []string{"tag:hr-webserver"},
 					},
-					&types.Machine{
-						IPAddresses: types.MachineAddresses{
+					&types.Node{
+						IPAddresses: types.NodeAddresses{
 							netip.MustParseAddr("100.64.0.3"),
 						},
 						User: types.User{Name: "marc"},
 					},
-					&types.Machine{
-						IPAddresses: types.MachineAddresses{
+					&types.Node{
+						IPAddresses: types.NodeAddresses{
 							netip.MustParseAddr("100.64.0.4"),
 						},
 						User: types.User{Name: "mickael"},
@@ -1375,16 +1375,16 @@ func Test_expandAlias(t *testing.T) {
 			},
 			args: args{
 				alias: "tag:hr-webserver",
-				machines: types.Machines{
-					&types.Machine{
-						IPAddresses: types.MachineAddresses{
+				nodes: types.Nodes{
+					&types.Node{
+						IPAddresses: types.NodeAddresses{
 							netip.MustParseAddr("100.64.0.1"),
 						},
 						User:       types.User{Name: "joe"},
 						ForcedTags: []string{"tag:hr-webserver"},
 					},
-					&types.Machine{
-						IPAddresses: types.MachineAddresses{
+					&types.Node{
+						IPAddresses: types.NodeAddresses{
 							netip.MustParseAddr("100.64.0.2"),
 						},
 						User: types.User{Name: "joe"},
@@ -1394,14 +1394,14 @@ func Test_expandAlias(t *testing.T) {
 							RequestTags: []string{"tag:hr-webserver"},
 						},
 					},
-					&types.Machine{
-						IPAddresses: types.MachineAddresses{
+					&types.Node{
+						IPAddresses: types.NodeAddresses{
 							netip.MustParseAddr("100.64.0.3"),
 						},
 						User: types.User{Name: "marc"},
 					},
-					&types.Machine{
-						IPAddresses: types.MachineAddresses{
+					&types.Node{
+						IPAddresses: types.NodeAddresses{
 							netip.MustParseAddr("100.64.0.4"),
 						},
 						User: types.User{Name: "mickael"},
@@ -1420,9 +1420,9 @@ func Test_expandAlias(t *testing.T) {
 			},
 			args: args{
 				alias: "joe",
-				machines: types.Machines{
-					&types.Machine{
-						IPAddresses: types.MachineAddresses{
+				nodes: types.Nodes{
+					&types.Node{
+						IPAddresses: types.NodeAddresses{
 							netip.MustParseAddr("100.64.0.1"),
 						},
 						User: types.User{Name: "joe"},
@@ -1432,8 +1432,8 @@ func Test_expandAlias(t *testing.T) {
 							RequestTags: []string{"tag:accountant-webserver"},
 						},
 					},
-					&types.Machine{
-						IPAddresses: types.MachineAddresses{
+					&types.Node{
+						IPAddresses: types.NodeAddresses{
 							netip.MustParseAddr("100.64.0.2"),
 						},
 						User: types.User{Name: "joe"},
@@ -1443,14 +1443,14 @@ func Test_expandAlias(t *testing.T) {
 							RequestTags: []string{"tag:accountant-webserver"},
 						},
 					},
-					&types.Machine{
-						IPAddresses: types.MachineAddresses{
+					&types.Node{
+						IPAddresses: types.NodeAddresses{
 							netip.MustParseAddr("100.64.0.3"),
 						},
 						User: types.User{Name: "marc"},
 					},
-					&types.Machine{
-						IPAddresses: types.MachineAddresses{
+					&types.Node{
+						IPAddresses: types.NodeAddresses{
 							netip.MustParseAddr("100.64.0.4"),
 						},
 						User: types.User{Name: "joe"},
@@ -1464,7 +1464,7 @@ func Test_expandAlias(t *testing.T) {
 	for _, test := range tests {
 		t.Run(test.name, func(t *testing.T) {
 			got, err := test.field.pol.ExpandAlias(
-				test.args.machines,
+				test.args.nodes,
 				test.args.alias,
 			)
 			if (err != nil) != test.wantErr {
@@ -1482,13 +1482,13 @@ func Test_expandAlias(t *testing.T) {
 func Test_excludeCorrectlyTaggedNodes(t *testing.T) {
 	type args struct {
 		aclPolicy *ACLPolicy
-		nodes     types.Machines
+		nodes     types.Nodes
 		user      string
 	}
 	tests := []struct {
 		name    string
 		args    args
-		want    types.Machines
+		want    types.Nodes
 		wantErr bool
 	}{
 		{
@@ -1497,9 +1497,9 @@ func Test_excludeCorrectlyTaggedNodes(t *testing.T) {
 				aclPolicy: &ACLPolicy{
 					TagOwners: TagOwners{"tag:accountant-webserver": []string{"joe"}},
 				},
-				nodes: types.Machines{
-					&types.Machine{
-						IPAddresses: types.MachineAddresses{
+				nodes: types.Nodes{
+					&types.Node{
+						IPAddresses: types.NodeAddresses{
 							netip.MustParseAddr("100.64.0.1"),
 						},
 						User: types.User{Name: "joe"},
@@ -1509,8 +1509,8 @@ func Test_excludeCorrectlyTaggedNodes(t *testing.T) {
 							RequestTags: []string{"tag:accountant-webserver"},
 						},
 					},
-					&types.Machine{
-						IPAddresses: types.MachineAddresses{
+					&types.Node{
+						IPAddresses: types.NodeAddresses{
 							netip.MustParseAddr("100.64.0.2"),
 						},
 						User: types.User{Name: "joe"},
@@ -1520,8 +1520,8 @@ func Test_excludeCorrectlyTaggedNodes(t *testing.T) {
 							RequestTags: []string{"tag:accountant-webserver"},
 						},
 					},
-					&types.Machine{
-						IPAddresses: types.MachineAddresses{
+					&types.Node{
+						IPAddresses: types.NodeAddresses{
 							netip.MustParseAddr("100.64.0.4"),
 						},
 						User: types.User{Name: "joe"},
@@ -1529,9 +1529,9 @@ func Test_excludeCorrectlyTaggedNodes(t *testing.T) {
 				},
 				user: "joe",
 			},
-			want: types.Machines{
-				&types.Machine{
-					IPAddresses: types.MachineAddresses{netip.MustParseAddr("100.64.0.4")},
+			want: types.Nodes{
+				&types.Node{
+					IPAddresses: types.NodeAddresses{netip.MustParseAddr("100.64.0.4")},
 					User:        types.User{Name: "joe"},
 				},
 			},
@@ -1547,9 +1547,9 @@ func Test_excludeCorrectlyTaggedNodes(t *testing.T) {
 						"tag:accountant-webserver": []string{"group:accountant"},
 					},
 				},
-				nodes: types.Machines{
-					&types.Machine{
-						IPAddresses: types.MachineAddresses{
+				nodes: types.Nodes{
+					&types.Node{
+						IPAddresses: types.NodeAddresses{
 							netip.MustParseAddr("100.64.0.1"),
 						},
 						User: types.User{Name: "joe"},
@@ -1559,8 +1559,8 @@ func Test_excludeCorrectlyTaggedNodes(t *testing.T) {
 							RequestTags: []string{"tag:accountant-webserver"},
 						},
 					},
-					&types.Machine{
-						IPAddresses: types.MachineAddresses{
+					&types.Node{
+						IPAddresses: types.NodeAddresses{
 							netip.MustParseAddr("100.64.0.2"),
 						},
 						User: types.User{Name: "joe"},
@@ -1570,8 +1570,8 @@ func Test_excludeCorrectlyTaggedNodes(t *testing.T) {
 							RequestTags: []string{"tag:accountant-webserver"},
 						},
 					},
-					&types.Machine{
-						IPAddresses: types.MachineAddresses{
+					&types.Node{
+						IPAddresses: types.NodeAddresses{
 							netip.MustParseAddr("100.64.0.4"),
 						},
 						User: types.User{Name: "joe"},
@@ -1579,9 +1579,9 @@ func Test_excludeCorrectlyTaggedNodes(t *testing.T) {
 				},
 				user: "joe",
 			},
-			want: types.Machines{
-				&types.Machine{
-					IPAddresses: types.MachineAddresses{netip.MustParseAddr("100.64.0.4")},
+			want: types.Nodes{
+				&types.Node{
+					IPAddresses: types.NodeAddresses{netip.MustParseAddr("100.64.0.4")},
 					User:        types.User{Name: "joe"},
 				},
 			},
@@ -1592,9 +1592,9 @@ func Test_excludeCorrectlyTaggedNodes(t *testing.T) {
 				aclPolicy: &ACLPolicy{
 					TagOwners: TagOwners{"tag:accountant-webserver": []string{"joe"}},
 				},
-				nodes: types.Machines{
-					&types.Machine{
-						IPAddresses: types.MachineAddresses{
+				nodes: types.Nodes{
+					&types.Node{
+						IPAddresses: types.NodeAddresses{
 							netip.MustParseAddr("100.64.0.1"),
 						},
 						User: types.User{Name: "joe"},
@@ -1604,15 +1604,15 @@ func Test_excludeCorrectlyTaggedNodes(t *testing.T) {
 							RequestTags: []string{"tag:accountant-webserver"},
 						},
 					},
-					&types.Machine{
-						IPAddresses: types.MachineAddresses{
+					&types.Node{
+						IPAddresses: types.NodeAddresses{
 							netip.MustParseAddr("100.64.0.2"),
 						},
 						User:       types.User{Name: "joe"},
 						ForcedTags: []string{"tag:accountant-webserver"},
 					},
-					&types.Machine{
-						IPAddresses: types.MachineAddresses{
+					&types.Node{
+						IPAddresses: types.NodeAddresses{
 							netip.MustParseAddr("100.64.0.4"),
 						},
 						User: types.User{Name: "joe"},
@@ -1620,9 +1620,9 @@ func Test_excludeCorrectlyTaggedNodes(t *testing.T) {
 				},
 				user: "joe",
 			},
-			want: types.Machines{
-				&types.Machine{
-					IPAddresses: types.MachineAddresses{netip.MustParseAddr("100.64.0.4")},
+			want: types.Nodes{
+				&types.Node{
+					IPAddresses: types.NodeAddresses{netip.MustParseAddr("100.64.0.4")},
 					User:        types.User{Name: "joe"},
 				},
 			},
@@ -1633,9 +1633,9 @@ func Test_excludeCorrectlyTaggedNodes(t *testing.T) {
 				aclPolicy: &ACLPolicy{
 					TagOwners: TagOwners{"tag:accountant-webserver": []string{"joe"}},
 				},
-				nodes: types.Machines{
-					&types.Machine{
-						IPAddresses: types.MachineAddresses{
+				nodes: types.Nodes{
+					&types.Node{
+						IPAddresses: types.NodeAddresses{
 							netip.MustParseAddr("100.64.0.1"),
 						},
 						User: types.User{Name: "joe"},
@@ -1645,8 +1645,8 @@ func Test_excludeCorrectlyTaggedNodes(t *testing.T) {
 							RequestTags: []string{"tag:hr-webserver"},
 						},
 					},
-					&types.Machine{
-						IPAddresses: types.MachineAddresses{
+					&types.Node{
+						IPAddresses: types.NodeAddresses{
 							netip.MustParseAddr("100.64.0.2"),
 						},
 						User: types.User{Name: "joe"},
@@ -1656,8 +1656,8 @@ func Test_excludeCorrectlyTaggedNodes(t *testing.T) {
 							RequestTags: []string{"tag:hr-webserver"},
 						},
 					},
-					&types.Machine{
-						IPAddresses: types.MachineAddresses{
+					&types.Node{
+						IPAddresses: types.NodeAddresses{
 							netip.MustParseAddr("100.64.0.4"),
 						},
 						User: types.User{Name: "joe"},
@@ -1665,9 +1665,9 @@ func Test_excludeCorrectlyTaggedNodes(t *testing.T) {
 				},
 				user: "joe",
 			},
-			want: types.Machines{
-				&types.Machine{
-					IPAddresses: types.MachineAddresses{
+			want: types.Nodes{
+				&types.Node{
+					IPAddresses: types.NodeAddresses{
 						netip.MustParseAddr("100.64.0.1"),
 					},
 					User: types.User{Name: "joe"},
@@ -1677,8 +1677,8 @@ func Test_excludeCorrectlyTaggedNodes(t *testing.T) {
 						RequestTags: []string{"tag:hr-webserver"},
 					},
 				},
-				&types.Machine{
-					IPAddresses: types.MachineAddresses{
+				&types.Node{
+					IPAddresses: types.NodeAddresses{
 						netip.MustParseAddr("100.64.0.2"),
 					},
 					User: types.User{Name: "joe"},
@@ -1688,8 +1688,8 @@ func Test_excludeCorrectlyTaggedNodes(t *testing.T) {
 						RequestTags: []string{"tag:hr-webserver"},
 					},
 				},
-				&types.Machine{
-					IPAddresses: types.MachineAddresses{
+				&types.Node{
+					IPAddresses: types.NodeAddresses{
 						netip.MustParseAddr("100.64.0.4"),
 					},
 					User: types.User{Name: "joe"},
@@ -1716,8 +1716,8 @@ func TestACLPolicy_generateFilterRules(t *testing.T) {
 		pol ACLPolicy
 	}
 	type args struct {
-		machine *types.Machine
-		peers   types.Machines
+		node  *types.Node
+		peers types.Nodes
 	}
 	tests := []struct {
 		name    string
@@ -1747,13 +1747,13 @@ func TestACLPolicy_generateFilterRules(t *testing.T) {
 				},
 			},
 			args: args{
-				machine: &types.Machine{
-					IPAddresses: types.MachineAddresses{
+				node: &types.Node{
+					IPAddresses: types.NodeAddresses{
 						netip.MustParseAddr("100.64.0.1"),
 						netip.MustParseAddr("fd7a:115c:a1e0:ab12:4843:2222:6273:2221"),
 					},
 				},
-				peers: types.Machines{},
+				peers: types.Nodes{},
 			},
 			want: []tailcfg.FilterRule{
 				{
@@ -1792,16 +1792,16 @@ func TestACLPolicy_generateFilterRules(t *testing.T) {
 				},
 			},
 			args: args{
-				machine: &types.Machine{
-					IPAddresses: types.MachineAddresses{
+				node: &types.Node{
+					IPAddresses: types.NodeAddresses{
 						netip.MustParseAddr("100.64.0.1"),
 						netip.MustParseAddr("fd7a:115c:a1e0:ab12:4843:2222:6273:2221"),
 					},
 					User: types.User{Name: "mickael"},
 				},
-				peers: types.Machines{
-					&types.Machine{
-						IPAddresses: types.MachineAddresses{
+				peers: types.Nodes{
+					&types.Node{
+						IPAddresses: types.NodeAddresses{
 							netip.MustParseAddr("100.64.0.2"),
 							netip.MustParseAddr("fd7a:115c:a1e0:ab12:4843:2222:6273:2222"),
 						},
@@ -1839,7 +1839,7 @@ func TestACLPolicy_generateFilterRules(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			got, err := tt.field.pol.generateFilterRules(
-				tt.args.machine,
+				tt.args.node,
 				tt.args.peers,
 			)
 			if (err != nil) != tt.wantErr {
@@ -1858,11 +1858,11 @@ func TestACLPolicy_generateFilterRules(t *testing.T) {
 
 func TestReduceFilterRules(t *testing.T) {
 	tests := []struct {
-		name    string
-		machine *types.Machine
-		peers   types.Machines
-		pol     ACLPolicy
-		want    []tailcfg.FilterRule
+		name  string
+		node  *types.Node
+		peers types.Nodes
+		pol   ACLPolicy
+		want  []tailcfg.FilterRule
 	}{
 		{
 			name: "host1-can-reach-host2-no-rules",
@@ -1875,16 +1875,16 @@ func TestReduceFilterRules(t *testing.T) {
 					},
 				},
 			},
-			machine: &types.Machine{
-				IPAddresses: types.MachineAddresses{
+			node: &types.Node{
+				IPAddresses: types.NodeAddresses{
 					netip.MustParseAddr("100.64.0.1"),
 					netip.MustParseAddr("fd7a:115c:a1e0:ab12:4843:2222:6273:2221"),
 				},
 				User: types.User{Name: "mickael"},
 			},
-			peers: types.Machines{
-				&types.Machine{
-					IPAddresses: types.MachineAddresses{
+			peers: types.Nodes{
+				&types.Node{
+					IPAddresses: types.NodeAddresses{
 						netip.MustParseAddr("100.64.0.2"),
 						netip.MustParseAddr("fd7a:115c:a1e0:ab12:4843:2222:6273:2222"),
 					},
@@ -1898,11 +1898,11 @@ func TestReduceFilterRules(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			rules, _ := tt.pol.generateFilterRules(
-				tt.machine,
+				tt.node,
 				tt.peers,
 			)
 
-			got := ReduceFilterRules(tt.machine, rules)
+			got := ReduceFilterRules(tt.node, rules)
 
 			if diff := cmp.Diff(tt.want, got); diff != "" {
 				log.Trace().Interface("got", got).Msg("result")
@@ -1915,7 +1915,7 @@ func TestReduceFilterRules(t *testing.T) {
 func Test_getTags(t *testing.T) {
 	type args struct {
 		aclPolicy *ACLPolicy
-		machine   *types.Machine
+		node      *types.Node
 	}
 	tests := []struct {
 		name        string
@@ -1924,14 +1924,14 @@ func Test_getTags(t *testing.T) {
 		wantValid   []string
 	}{
 		{
-			name: "valid tag one machine",
+			name: "valid tag one nodes",
 			args: args{
 				aclPolicy: &ACLPolicy{
 					TagOwners: TagOwners{
 						"tag:valid": []string{"joe"},
 					},
 				},
-				machine: &types.Machine{
+				node: &types.Node{
 					User: types.User{
 						Name: "joe",
 					},
@@ -1944,14 +1944,14 @@ func Test_getTags(t *testing.T) {
 			wantInvalid: nil,
 		},
 		{
-			name: "invalid tag and valid tag one machine",
+			name: "invalid tag and valid tag one nodes",
 			args: args{
 				aclPolicy: &ACLPolicy{
 					TagOwners: TagOwners{
 						"tag:valid": []string{"joe"},
 					},
 				},
-				machine: &types.Machine{
+				node: &types.Node{
 					User: types.User{
 						Name: "joe",
 					},
@@ -1971,7 +1971,7 @@ func Test_getTags(t *testing.T) {
 						"tag:valid": []string{"joe"},
 					},
 				},
-				machine: &types.Machine{
+				node: &types.Node{
 					User: types.User{
 						Name: "joe",
 					},
@@ -1995,7 +1995,7 @@ func Test_getTags(t *testing.T) {
 						"tag:valid": []string{"joe"},
 					},
 				},
-				machine: &types.Machine{
+				node: &types.Node{
 					User: types.User{
 						Name: "joe",
 					},
@@ -2011,7 +2011,7 @@ func Test_getTags(t *testing.T) {
 			name: "empty ACLPolicy should return empty tags and should not panic",
 			args: args{
 				aclPolicy: &ACLPolicy{},
-				machine: &types.Machine{
+				node: &types.Node{
 					User: types.User{
 						Name: "joe",
 					},
@@ -2026,8 +2026,8 @@ func Test_getTags(t *testing.T) {
 	}
 	for _, test := range tests {
 		t.Run(test.name, func(t *testing.T) {
-			gotValid, gotInvalid := test.args.aclPolicy.TagsOfMachine(
-				test.args.machine,
+			gotValid, gotInvalid := test.args.aclPolicy.TagsOfNode(
+				test.args.node,
 			)
 			for _, valid := range gotValid {
 				if !util.StringOrPrefixListContains(test.wantValid, valid) {
@@ -2061,36 +2061,36 @@ func Test_getFilteredByACLPeers(t *testing.T) {
 	})
 
 	type args struct {
-		machines types.Machines
-		rules    []tailcfg.FilterRule
-		machine  *types.Machine
+		nodes types.Nodes
+		rules []tailcfg.FilterRule
+		node  *types.Node
 	}
 	tests := []struct {
 		name string
 		args args
-		want types.Machines
+		want types.Nodes
 	}{
 		{
 			name: "all hosts can talk to each other",
 			args: args{
-				machines: types.Machines{ // list of all machines in the database
-					&types.Machine{
+				nodes: types.Nodes{ // list of all nodess in the database
+					&types.Node{
 						ID: 1,
-						IPAddresses: types.MachineAddresses{
+						IPAddresses: types.NodeAddresses{
 							netip.MustParseAddr("100.64.0.1"),
 						},
 						User: types.User{Name: "joe"},
 					},
-					&types.Machine{
+					&types.Node{
 						ID: 2,
-						IPAddresses: types.MachineAddresses{
+						IPAddresses: types.NodeAddresses{
 							netip.MustParseAddr("100.64.0.2"),
 						},
 						User: types.User{Name: "marc"},
 					},
-					&types.Machine{
+					&types.Node{
 						ID: 3,
-						IPAddresses: types.MachineAddresses{
+						IPAddresses: types.NodeAddresses{
 							netip.MustParseAddr("100.64.0.3"),
 						},
 						User: types.User{Name: "mickael"},
@@ -2104,21 +2104,21 @@ func Test_getFilteredByACLPeers(t *testing.T) {
 						},
 					},
 				},
-				machine: &types.Machine{ // current machine
+				node: &types.Node{ // current nodes
 					ID:          1,
-					IPAddresses: types.MachineAddresses{netip.MustParseAddr("100.64.0.1")},
+					IPAddresses: types.NodeAddresses{netip.MustParseAddr("100.64.0.1")},
 					User:        types.User{Name: "joe"},
 				},
 			},
-			want: types.Machines{
-				&types.Machine{
+			want: types.Nodes{
+				&types.Node{
 					ID:          2,
-					IPAddresses: types.MachineAddresses{netip.MustParseAddr("100.64.0.2")},
+					IPAddresses: types.NodeAddresses{netip.MustParseAddr("100.64.0.2")},
 					User:        types.User{Name: "marc"},
 				},
-				&types.Machine{
+				&types.Node{
 					ID:          3,
-					IPAddresses: types.MachineAddresses{netip.MustParseAddr("100.64.0.3")},
+					IPAddresses: types.NodeAddresses{netip.MustParseAddr("100.64.0.3")},
 					User:        types.User{Name: "mickael"},
 				},
 			},
@@ -2126,24 +2126,24 @@ func Test_getFilteredByACLPeers(t *testing.T) {
 		{
 			name: "One host can talk to another, but not all hosts",
 			args: args{
-				machines: types.Machines{ // list of all machines in the database
-					&types.Machine{
+				nodes: types.Nodes{ // list of all nodess in the database
+					&types.Node{
 						ID: 1,
-						IPAddresses: types.MachineAddresses{
+						IPAddresses: types.NodeAddresses{
 							netip.MustParseAddr("100.64.0.1"),
 						},
 						User: types.User{Name: "joe"},
 					},
-					&types.Machine{
+					&types.Node{
 						ID: 2,
-						IPAddresses: types.MachineAddresses{
+						IPAddresses: types.NodeAddresses{
 							netip.MustParseAddr("100.64.0.2"),
 						},
 						User: types.User{Name: "marc"},
 					},
-					&types.Machine{
+					&types.Node{
 						ID: 3,
-						IPAddresses: types.MachineAddresses{
+						IPAddresses: types.NodeAddresses{
 							netip.MustParseAddr("100.64.0.3"),
 						},
 						User: types.User{Name: "mickael"},
@@ -2157,16 +2157,16 @@ func Test_getFilteredByACLPeers(t *testing.T) {
 						},
 					},
 				},
-				machine: &types.Machine{ // current machine
+				node: &types.Node{ // current nodes
 					ID:          1,
-					IPAddresses: types.MachineAddresses{netip.MustParseAddr("100.64.0.1")},
+					IPAddresses: types.NodeAddresses{netip.MustParseAddr("100.64.0.1")},
 					User:        types.User{Name: "joe"},
 				},
 			},
-			want: types.Machines{
-				&types.Machine{
+			want: types.Nodes{
+				&types.Node{
 					ID:          2,
-					IPAddresses: types.MachineAddresses{netip.MustParseAddr("100.64.0.2")},
+					IPAddresses: types.NodeAddresses{netip.MustParseAddr("100.64.0.2")},
 					User:        types.User{Name: "marc"},
 				},
 			},
@@ -2174,24 +2174,24 @@ func Test_getFilteredByACLPeers(t *testing.T) {
 		{
 			name: "host cannot directly talk to destination, but return path is authorized",
 			args: args{
-				machines: types.Machines{ // list of all machines in the database
-					&types.Machine{
+				nodes: types.Nodes{ // list of all nodess in the database
+					&types.Node{
 						ID: 1,
-						IPAddresses: types.MachineAddresses{
+						IPAddresses: types.NodeAddresses{
 							netip.MustParseAddr("100.64.0.1"),
 						},
 						User: types.User{Name: "joe"},
 					},
-					&types.Machine{
+					&types.Node{
 						ID: 2,
-						IPAddresses: types.MachineAddresses{
+						IPAddresses: types.NodeAddresses{
 							netip.MustParseAddr("100.64.0.2"),
 						},
 						User: types.User{Name: "marc"},
 					},
-					&types.Machine{
+					&types.Node{
 						ID: 3,
-						IPAddresses: types.MachineAddresses{
+						IPAddresses: types.NodeAddresses{
 							netip.MustParseAddr("100.64.0.3"),
 						},
 						User: types.User{Name: "mickael"},
@@ -2205,16 +2205,16 @@ func Test_getFilteredByACLPeers(t *testing.T) {
 						},
 					},
 				},
-				machine: &types.Machine{ // current machine
+				node: &types.Node{ // current nodes
 					ID:          2,
-					IPAddresses: types.MachineAddresses{netip.MustParseAddr("100.64.0.2")},
+					IPAddresses: types.NodeAddresses{netip.MustParseAddr("100.64.0.2")},
 					User:        types.User{Name: "marc"},
 				},
 			},
-			want: types.Machines{
-				&types.Machine{
+			want: types.Nodes{
+				&types.Node{
 					ID:          3,
-					IPAddresses: types.MachineAddresses{netip.MustParseAddr("100.64.0.3")},
+					IPAddresses: types.NodeAddresses{netip.MustParseAddr("100.64.0.3")},
 					User:        types.User{Name: "mickael"},
 				},
 			},
@@ -2222,24 +2222,24 @@ func Test_getFilteredByACLPeers(t *testing.T) {
 		{
 			name: "rules allows all hosts to reach one destination",
 			args: args{
-				machines: types.Machines{ // list of all machines in the database
-					&types.Machine{
+				nodes: types.Nodes{ // list of all nodess in the database
+					&types.Node{
 						ID: 1,
-						IPAddresses: types.MachineAddresses{
+						IPAddresses: types.NodeAddresses{
 							netip.MustParseAddr("100.64.0.1"),
 						},
 						User: types.User{Name: "joe"},
 					},
-					&types.Machine{
+					&types.Node{
 						ID: 2,
-						IPAddresses: types.MachineAddresses{
+						IPAddresses: types.NodeAddresses{
 							netip.MustParseAddr("100.64.0.2"),
 						},
 						User: types.User{Name: "marc"},
 					},
-					&types.Machine{
+					&types.Node{
 						ID: 3,
-						IPAddresses: types.MachineAddresses{
+						IPAddresses: types.NodeAddresses{
 							netip.MustParseAddr("100.64.0.3"),
 						},
 						User: types.User{Name: "mickael"},
@@ -2253,18 +2253,18 @@ func Test_getFilteredByACLPeers(t *testing.T) {
 						},
 					},
 				},
-				machine: &types.Machine{ // current machine
+				node: &types.Node{ // current nodes
 					ID: 1,
-					IPAddresses: types.MachineAddresses{
+					IPAddresses: types.NodeAddresses{
 						netip.MustParseAddr("100.64.0.1"),
 					},
 					User: types.User{Name: "joe"},
 				},
 			},
-			want: types.Machines{
-				&types.Machine{
+			want: types.Nodes{
+				&types.Node{
 					ID: 2,
-					IPAddresses: types.MachineAddresses{
+					IPAddresses: types.NodeAddresses{
 						netip.MustParseAddr("100.64.0.2"),
 					},
 					User: types.User{Name: "marc"},
@@ -2274,24 +2274,24 @@ func Test_getFilteredByACLPeers(t *testing.T) {
 		{
 			name: "rules allows all hosts to reach one destination, destination can reach all hosts",
 			args: args{
-				machines: types.Machines{ // list of all machines in the database
-					&types.Machine{
+				nodes: types.Nodes{ // list of all nodess in the database
+					&types.Node{
 						ID: 1,
-						IPAddresses: types.MachineAddresses{
+						IPAddresses: types.NodeAddresses{
 							netip.MustParseAddr("100.64.0.1"),
 						},
 						User: types.User{Name: "joe"},
 					},
-					&types.Machine{
+					&types.Node{
 						ID: 2,
-						IPAddresses: types.MachineAddresses{
+						IPAddresses: types.NodeAddresses{
 							netip.MustParseAddr("100.64.0.2"),
 						},
 						User: types.User{Name: "marc"},
 					},
-					&types.Machine{
+					&types.Node{
 						ID: 3,
-						IPAddresses: types.MachineAddresses{
+						IPAddresses: types.NodeAddresses{
 							netip.MustParseAddr("100.64.0.3"),
 						},
 						User: types.User{Name: "mickael"},
@@ -2305,25 +2305,25 @@ func Test_getFilteredByACLPeers(t *testing.T) {
 						},
 					},
 				},
-				machine: &types.Machine{ // current machine
+				node: &types.Node{ // current nodes
 					ID: 2,
-					IPAddresses: types.MachineAddresses{
+					IPAddresses: types.NodeAddresses{
 						netip.MustParseAddr("100.64.0.2"),
 					},
 					User: types.User{Name: "marc"},
 				},
 			},
-			want: types.Machines{
-				&types.Machine{
+			want: types.Nodes{
+				&types.Node{
 					ID: 1,
-					IPAddresses: types.MachineAddresses{
+					IPAddresses: types.NodeAddresses{
 						netip.MustParseAddr("100.64.0.1"),
 					},
 					User: types.User{Name: "joe"},
 				},
-				&types.Machine{
+				&types.Node{
 					ID: 3,
-					IPAddresses: types.MachineAddresses{
+					IPAddresses: types.NodeAddresses{
 						netip.MustParseAddr("100.64.0.3"),
 					},
 					User: types.User{Name: "mickael"},
@@ -2333,24 +2333,24 @@ func Test_getFilteredByACLPeers(t *testing.T) {
 		{
 			name: "rule allows all hosts to reach all destinations",
 			args: args{
-				machines: types.Machines{ // list of all machines in the database
-					&types.Machine{
+				nodes: types.Nodes{ // list of all nodess in the database
+					&types.Node{
 						ID: 1,
-						IPAddresses: types.MachineAddresses{
+						IPAddresses: types.NodeAddresses{
 							netip.MustParseAddr("100.64.0.1"),
 						},
 						User: types.User{Name: "joe"},
 					},
-					&types.Machine{
+					&types.Node{
 						ID: 2,
-						IPAddresses: types.MachineAddresses{
+						IPAddresses: types.NodeAddresses{
 							netip.MustParseAddr("100.64.0.2"),
 						},
 						User: types.User{Name: "marc"},
 					},
-					&types.Machine{
+					&types.Node{
 						ID: 3,
-						IPAddresses: types.MachineAddresses{
+						IPAddresses: types.NodeAddresses{
 							netip.MustParseAddr("100.64.0.3"),
 						},
 						User: types.User{Name: "mickael"},
@@ -2364,23 +2364,23 @@ func Test_getFilteredByACLPeers(t *testing.T) {
 						},
 					},
 				},
-				machine: &types.Machine{ // current machine
+				node: &types.Node{ // current nodes
 					ID:          2,
-					IPAddresses: types.MachineAddresses{netip.MustParseAddr("100.64.0.2")},
+					IPAddresses: types.NodeAddresses{netip.MustParseAddr("100.64.0.2")},
 					User:        types.User{Name: "marc"},
 				},
 			},
-			want: types.Machines{
-				&types.Machine{
+			want: types.Nodes{
+				&types.Node{
 					ID: 1,
-					IPAddresses: types.MachineAddresses{
+					IPAddresses: types.NodeAddresses{
 						netip.MustParseAddr("100.64.0.1"),
 					},
 					User: types.User{Name: "joe"},
 				},
-				&types.Machine{
+				&types.Node{
 					ID:          3,
-					IPAddresses: types.MachineAddresses{netip.MustParseAddr("100.64.0.3")},
+					IPAddresses: types.NodeAddresses{netip.MustParseAddr("100.64.0.3")},
 					User:        types.User{Name: "mickael"},
 				},
 			},
@@ -2388,24 +2388,24 @@ func Test_getFilteredByACLPeers(t *testing.T) {
 		{
 			name: "without rule all communications are forbidden",
 			args: args{
-				machines: types.Machines{ // list of all machines in the database
-					&types.Machine{
+				nodes: types.Nodes{ // list of all nodess in the database
+					&types.Node{
 						ID: 1,
-						IPAddresses: types.MachineAddresses{
+						IPAddresses: types.NodeAddresses{
 							netip.MustParseAddr("100.64.0.1"),
 						},
 						User: types.User{Name: "joe"},
 					},
-					&types.Machine{
+					&types.Node{
 						ID: 2,
-						IPAddresses: types.MachineAddresses{
+						IPAddresses: types.NodeAddresses{
 							netip.MustParseAddr("100.64.0.2"),
 						},
 						User: types.User{Name: "marc"},
 					},
-					&types.Machine{
+					&types.Node{
 						ID: 3,
-						IPAddresses: types.MachineAddresses{
+						IPAddresses: types.NodeAddresses{
 							netip.MustParseAddr("100.64.0.3"),
 						},
 						User: types.User{Name: "mickael"},
@@ -2413,53 +2413,53 @@ func Test_getFilteredByACLPeers(t *testing.T) {
 				},
 				rules: []tailcfg.FilterRule{ // list of all ACLRules registered
 				},
-				machine: &types.Machine{ // current machine
+				node: &types.Node{ // current nodes
 					ID:          2,
-					IPAddresses: types.MachineAddresses{netip.MustParseAddr("100.64.0.2")},
+					IPAddresses: types.NodeAddresses{netip.MustParseAddr("100.64.0.2")},
 					User:        types.User{Name: "marc"},
 				},
 			},
-			want: types.Machines{},
+			want: types.Nodes{},
 		},
 		{
 			// Investigating 699
-			// Found some machines: [ts-head-8w6paa ts-unstable-lys2ib ts-head-upcrmb ts-unstable-rlwpvr] machine=ts-head-8w6paa
+			// Found some nodes: [ts-head-8w6paa ts-unstable-lys2ib ts-head-upcrmb ts-unstable-rlwpvr] nodes=ts-head-8w6paa
 			// ACL rules generated ACL=[{"DstPorts":[{"Bits":null,"IP":"*","Ports":{"First":0,"Last":65535}}],"SrcIPs":["fd7a:115c:a1e0::3","100.64.0.3","fd7a:115c:a1e0::4","100.64.0.4"]}]
 			// ACL Cache Map={"100.64.0.3":{"*":{}},"100.64.0.4":{"*":{}},"fd7a:115c:a1e0::3":{"*":{}},"fd7a:115c:a1e0::4":{"*":{}}}
 			name: "issue-699-broken-star",
 			args: args{
-				machines: types.Machines{ //
-					&types.Machine{
+				nodes: types.Nodes{ //
+					&types.Node{
 						ID:       1,
 						Hostname: "ts-head-upcrmb",
-						IPAddresses: types.MachineAddresses{
+						IPAddresses: types.NodeAddresses{
 							netip.MustParseAddr("100.64.0.3"),
 							netip.MustParseAddr("fd7a:115c:a1e0::3"),
 						},
 						User: types.User{Name: "user1"},
 					},
-					&types.Machine{
+					&types.Node{
 						ID:       2,
 						Hostname: "ts-unstable-rlwpvr",
-						IPAddresses: types.MachineAddresses{
+						IPAddresses: types.NodeAddresses{
 							netip.MustParseAddr("100.64.0.4"),
 							netip.MustParseAddr("fd7a:115c:a1e0::4"),
 						},
 						User: types.User{Name: "user1"},
 					},
-					&types.Machine{
+					&types.Node{
 						ID:       3,
 						Hostname: "ts-head-8w6paa",
-						IPAddresses: types.MachineAddresses{
+						IPAddresses: types.NodeAddresses{
 							netip.MustParseAddr("100.64.0.1"),
 							netip.MustParseAddr("fd7a:115c:a1e0::1"),
 						},
 						User: types.User{Name: "user2"},
 					},
-					&types.Machine{
+					&types.Node{
 						ID:       4,
 						Hostname: "ts-unstable-lys2ib",
-						IPAddresses: types.MachineAddresses{
+						IPAddresses: types.NodeAddresses{
 							netip.MustParseAddr("100.64.0.2"),
 							netip.MustParseAddr("fd7a:115c:a1e0::2"),
 						},
@@ -2480,30 +2480,30 @@ func Test_getFilteredByACLPeers(t *testing.T) {
 						},
 					},
 				},
-				machine: &types.Machine{ // current machine
+				node: &types.Node{ // current nodes
 					ID:       3,
 					Hostname: "ts-head-8w6paa",
-					IPAddresses: types.MachineAddresses{
+					IPAddresses: types.NodeAddresses{
 						netip.MustParseAddr("100.64.0.1"),
 						netip.MustParseAddr("fd7a:115c:a1e0::1"),
 					},
 					User: types.User{Name: "user2"},
 				},
 			},
-			want: types.Machines{
-				&types.Machine{
+			want: types.Nodes{
+				&types.Node{
 					ID:       1,
 					Hostname: "ts-head-upcrmb",
-					IPAddresses: types.MachineAddresses{
+					IPAddresses: types.NodeAddresses{
 						netip.MustParseAddr("100.64.0.3"),
 						netip.MustParseAddr("fd7a:115c:a1e0::3"),
 					},
 					User: types.User{Name: "user1"},
 				},
-				&types.Machine{
+				&types.Node{
 					ID:       2,
 					Hostname: "ts-unstable-rlwpvr",
-					IPAddresses: types.MachineAddresses{
+					IPAddresses: types.NodeAddresses{
 						netip.MustParseAddr("100.64.0.4"),
 						netip.MustParseAddr("fd7a:115c:a1e0::4"),
 					},
@@ -2514,7 +2514,7 @@ func Test_getFilteredByACLPeers(t *testing.T) {
 		{
 			name: "failing-edge-case-during-p3-refactor",
 			args: args{
-				machines: []*types.Machine{
+				nodes: []*types.Node{
 					{
 						ID:          1,
 						IPAddresses: []netip.Addr{netip.MustParseAddr("100.64.0.2")},
@@ -2537,14 +2537,14 @@ func Test_getFilteredByACLPeers(t *testing.T) {
 						},
 					},
 				},
-				machine: &types.Machine{
+				node: &types.Node{
 					ID:          0,
 					IPAddresses: []netip.Addr{netip.MustParseAddr("100.64.0.1")},
 					Hostname:    "mini",
 					User:        types.User{Name: "mini"},
 				},
 			},
-			want: []*types.Machine{
+			want: []*types.Node{
 				{
 					ID:          2,
 					IPAddresses: []netip.Addr{netip.MustParseAddr("100.64.0.3")},
@@ -2556,7 +2556,7 @@ func Test_getFilteredByACLPeers(t *testing.T) {
 		{
 			name: "p4-host-in-netmap-user2-dest-bug",
 			args: args{
-				machines: []*types.Machine{
+				nodes: []*types.Node{
 					{
 						ID:          1,
 						IPAddresses: []netip.Addr{netip.MustParseAddr("100.64.0.2")},
@@ -2606,14 +2606,14 @@ func Test_getFilteredByACLPeers(t *testing.T) {
 						},
 					},
 				},
-				machine: &types.Machine{
+				node: &types.Node{
 					ID:          2,
 					IPAddresses: []netip.Addr{netip.MustParseAddr("100.64.0.3")},
 					Hostname:    "user-2-1",
 					User:        types.User{Name: "user2"},
 				},
 			},
-			want: []*types.Machine{
+			want: []*types.Node{
 				{
 					ID:          1,
 					IPAddresses: []netip.Addr{netip.MustParseAddr("100.64.0.2")},
@@ -2637,7 +2637,7 @@ func Test_getFilteredByACLPeers(t *testing.T) {
 		{
 			name: "p4-host-in-netmap-user1-dest-bug",
 			args: args{
-				machines: []*types.Machine{
+				nodes: []*types.Node{
 					{
 						ID:          1,
 						IPAddresses: []netip.Addr{netip.MustParseAddr("100.64.0.2")},
@@ -2687,14 +2687,14 @@ func Test_getFilteredByACLPeers(t *testing.T) {
 						},
 					},
 				},
-				machine: &types.Machine{
+				node: &types.Node{
 					ID:          0,
 					IPAddresses: []netip.Addr{netip.MustParseAddr("100.64.0.1")},
 					Hostname:    "user1-1",
 					User:        types.User{Name: "user1"},
 				},
 			},
-			want: []*types.Machine{
+			want: []*types.Node{
 				{
 					ID:          1,
 					IPAddresses: []netip.Addr{netip.MustParseAddr("100.64.0.2")},
@@ -2718,13 +2718,13 @@ func Test_getFilteredByACLPeers(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			got := FilterMachinesByACL(
-				tt.args.machine,
-				tt.args.machines,
+			got := FilterNodesByACL(
+				tt.args.node,
+				tt.args.nodes,
 				tt.args.rules,
 			)
 			if diff := cmp.Diff(tt.want, got, ipComparer); diff != "" {
-				t.Errorf("FilterMachinesByACL() unexpected result (-want +got):\n%s", diff)
+				t.Errorf("FilterNodesByACL() unexpected result (-want +got):\n%s", diff)
 			}
 		})
 	}
@@ -2732,26 +2732,26 @@ func Test_getFilteredByACLPeers(t *testing.T) {
 
 func TestSSHRules(t *testing.T) {
 	tests := []struct {
-		name    string
-		machine types.Machine
-		peers   types.Machines
-		pol     ACLPolicy
-		want    []*tailcfg.SSHRule
+		name  string
+		node  types.Node
+		peers types.Nodes
+		pol   ACLPolicy
+		want  []*tailcfg.SSHRule
 	}{
 		{
 			name: "peers-can-connect",
-			machine: types.Machine{
-				Hostname:    "testmachine",
-				IPAddresses: types.MachineAddresses{netip.MustParseAddr("100.64.99.42")},
+			node: types.Node{
+				Hostname:    "testnodes",
+				IPAddresses: types.NodeAddresses{netip.MustParseAddr("100.64.99.42")},
 				UserID:      0,
 				User: types.User{
 					Name: "user1",
 				},
 			},
-			peers: types.Machines{
-				&types.Machine{
-					Hostname:    "testmachine2",
-					IPAddresses: types.MachineAddresses{netip.MustParseAddr("100.64.0.1")},
+			peers: types.Nodes{
+				&types.Node{
+					Hostname:    "testnodes2",
+					IPAddresses: types.NodeAddresses{netip.MustParseAddr("100.64.0.1")},
 					UserID:      0,
 					User: types.User{
 						Name: "user1",
@@ -2848,18 +2848,18 @@ func TestSSHRules(t *testing.T) {
 		},
 		{
 			name: "peers-cannot-connect",
-			machine: types.Machine{
-				Hostname:    "testmachine",
-				IPAddresses: types.MachineAddresses{netip.MustParseAddr("100.64.0.1")},
+			node: types.Node{
+				Hostname:    "testnodes",
+				IPAddresses: types.NodeAddresses{netip.MustParseAddr("100.64.0.1")},
 				UserID:      0,
 				User: types.User{
 					Name: "user1",
 				},
 			},
-			peers: types.Machines{
-				&types.Machine{
-					Hostname:    "testmachine2",
-					IPAddresses: types.MachineAddresses{netip.MustParseAddr("100.64.99.42")},
+			peers: types.Nodes{
+				&types.Node{
+					Hostname:    "testnodes2",
+					IPAddresses: types.NodeAddresses{netip.MustParseAddr("100.64.99.42")},
 					UserID:      0,
 					User: types.User{
 						Name: "user1",
@@ -2901,7 +2901,7 @@ func TestSSHRules(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			got, err := tt.pol.generateSSHRules(&tt.machine, tt.peers)
+			got, err := tt.pol.generateSSHRules(&tt.node, tt.peers)
 			assert.NoError(t, err)
 
 			if diff := cmp.Diff(tt.want, got); diff != "" {
@@ -2980,17 +2980,17 @@ func TestParseDestination(t *testing.T) {
 func TestValidExpandTagOwnersInSources(t *testing.T) {
 	hostInfo := tailcfg.Hostinfo{
 		OS:          "centos",
-		Hostname:    "testmachine",
+		Hostname:    "testnodes",
 		RequestTags: []string{"tag:test"},
 	}
 
-	machine := &types.Machine{
+	node := &types.Node{
 		ID:          0,
 		MachineKey:  "foo",
 		NodeKey:     "bar",
 		DiscoKey:    "faa",
-		Hostname:    "testmachine",
-		IPAddresses: types.MachineAddresses{netip.MustParseAddr("100.64.0.1")},
+		Hostname:    "testnodes",
+		IPAddresses: types.NodeAddresses{netip.MustParseAddr("100.64.0.1")},
 		UserID:      0,
 		User: types.User{
 			Name: "user1",
@@ -3011,7 +3011,7 @@ func TestValidExpandTagOwnersInSources(t *testing.T) {
 		},
 	}
 
-	got, _, err := GenerateFilterAndSSHRules(pol, machine, types.Machines{})
+	got, _, err := GenerateFilterAndSSHRules(pol, node, types.Nodes{})
 	assert.NoError(t, err)
 
 	want := []tailcfg.FilterRule{
@@ -3035,17 +3035,17 @@ func TestValidExpandTagOwnersInSources(t *testing.T) {
 func TestInvalidTagValidUser(t *testing.T) {
 	hostInfo := tailcfg.Hostinfo{
 		OS:          "centos",
-		Hostname:    "testmachine",
+		Hostname:    "testnodes",
 		RequestTags: []string{"tag:foo"},
 	}
 
-	machine := &types.Machine{
+	node := &types.Node{
 		ID:          1,
 		MachineKey:  "12345",
 		NodeKey:     "bar",
 		DiscoKey:    "faa",
-		Hostname:    "testmachine",
-		IPAddresses: types.MachineAddresses{netip.MustParseAddr("100.64.0.1")},
+		Hostname:    "testnodes",
+		IPAddresses: types.NodeAddresses{netip.MustParseAddr("100.64.0.1")},
 		UserID:      1,
 		User: types.User{
 			Name: "user1",
@@ -3065,7 +3065,7 @@ func TestInvalidTagValidUser(t *testing.T) {
 		},
 	}
 
-	got, _, err := GenerateFilterAndSSHRules(pol, machine, types.Machines{})
+	got, _, err := GenerateFilterAndSSHRules(pol, node, types.Nodes{})
 	assert.NoError(t, err)
 
 	want := []tailcfg.FilterRule{
@@ -3089,17 +3089,17 @@ func TestInvalidTagValidUser(t *testing.T) {
 func TestValidExpandTagOwnersInDestinations(t *testing.T) {
 	hostInfo := tailcfg.Hostinfo{
 		OS:          "centos",
-		Hostname:    "testmachine",
+		Hostname:    "testnodes",
 		RequestTags: []string{"tag:test"},
 	}
 
-	machine := &types.Machine{
+	node := &types.Node{
 		ID:          1,
 		MachineKey:  "12345",
 		NodeKey:     "bar",
 		DiscoKey:    "faa",
-		Hostname:    "testmachine",
-		IPAddresses: types.MachineAddresses{netip.MustParseAddr("100.64.0.1")},
+		Hostname:    "testnodes",
+		IPAddresses: types.NodeAddresses{netip.MustParseAddr("100.64.0.1")},
 		UserID:      1,
 		User: types.User{
 			Name: "user1",
@@ -3120,14 +3120,14 @@ func TestValidExpandTagOwnersInDestinations(t *testing.T) {
 		},
 	}
 
-	// rules, _, err := GenerateFilterRules(pol, &machine, peers, false)
+	// rules, _, err := GenerateFilterRules(pol, &node, peers, false)
 	// c.Assert(err, check.IsNil)
 	//
 	// c.Assert(rules, check.HasLen, 1)
 	// c.Assert(rules[0].DstPorts, check.HasLen, 1)
 	// c.Assert(rules[0].DstPorts[0].IP, check.Equals, "100.64.0.1/32")
 
-	got, _, err := GenerateFilterAndSSHRules(pol, machine, types.Machines{})
+	got, _, err := GenerateFilterAndSSHRules(pol, node, types.Nodes{})
 	assert.NoError(t, err)
 
 	want := []tailcfg.FilterRule{
@@ -3157,13 +3157,13 @@ func TestValidTagInvalidUser(t *testing.T) {
 		RequestTags: []string{"tag:webapp"},
 	}
 
-	machine := &types.Machine{
+	node := &types.Node{
 		ID:          1,
 		MachineKey:  "12345",
 		NodeKey:     "bar",
 		DiscoKey:    "faa",
 		Hostname:    "webserver",
-		IPAddresses: types.MachineAddresses{netip.MustParseAddr("100.64.0.1")},
+		IPAddresses: types.NodeAddresses{netip.MustParseAddr("100.64.0.1")},
 		UserID:      1,
 		User: types.User{
 			Name: "user1",
@@ -3177,13 +3177,13 @@ func TestValidTagInvalidUser(t *testing.T) {
 		Hostname: "Hostname",
 	}
 
-	machine2 := &types.Machine{
+	nodes2 := &types.Node{
 		ID:          2,
 		MachineKey:  "56789",
 		NodeKey:     "bar2",
 		DiscoKey:    "faab",
 		Hostname:    "user",
-		IPAddresses: types.MachineAddresses{netip.MustParseAddr("100.64.0.2")},
+		IPAddresses: types.NodeAddresses{netip.MustParseAddr("100.64.0.2")},
 		UserID:      1,
 		User: types.User{
 			Name: "user1",
@@ -3203,7 +3203,7 @@ func TestValidTagInvalidUser(t *testing.T) {
 		},
 	}
 
-	got, _, err := GenerateFilterAndSSHRules(pol, machine, types.Machines{machine2})
+	got, _, err := GenerateFilterAndSSHRules(pol, node, types.Nodes{nodes2})
 	assert.NoError(t, err)
 
 	want := []tailcfg.FilterRule{
diff --git a/hscontrol/poll.go b/hscontrol/poll.go
index 45abe56424..00f2c301b9 100644
--- a/hscontrol/poll.go
+++ b/hscontrol/poll.go
@@ -19,13 +19,13 @@ const (
 
 type contextKey string
 
-const machineNameContextKey = contextKey("machineName")
+const nodeNameContextKey = contextKey("nodeName")
 
 type UpdateNode func()
 
 func logPollFunc(
 	mapRequest tailcfg.MapRequest,
-	machine *types.Machine,
+	node *types.Node,
 	isNoise bool,
 ) (func(string), func(error, string)) {
 	return func(msg string) {
@@ -35,8 +35,8 @@ func logPollFunc(
 				Bool("readOnly", mapRequest.ReadOnly).
 				Bool("omitPeers", mapRequest.OmitPeers).
 				Bool("stream", mapRequest.Stream).
-				Str("node_key", machine.NodeKey).
-				Str("machine", machine.Hostname).
+				Str("node_key", node.NodeKey).
+				Str("node", node.Hostname).
 				Msg(msg)
 		},
 		func(err error, msg string) {
@@ -46,8 +46,8 @@ func logPollFunc(
 				Bool("readOnly", mapRequest.ReadOnly).
 				Bool("omitPeers", mapRequest.OmitPeers).
 				Bool("stream", mapRequest.Stream).
-				Str("node_key", machine.NodeKey).
-				Str("machine", machine.Hostname).
+				Str("node_key", node.NodeKey).
+				Str("node", node.Hostname).
 				Err(err).
 				Msg(msg)
 		}
@@ -60,11 +60,11 @@ func logPollFunc(
 func (h *Headscale) handlePoll(
 	writer http.ResponseWriter,
 	ctx context.Context,
-	machine *types.Machine,
+	node *types.Node,
 	mapRequest tailcfg.MapRequest,
 	isNoise bool,
 ) {
-	logInfo, logErr := logPollFunc(mapRequest, machine, isNoise)
+	logInfo, logErr := logPollFunc(mapRequest, node, isNoise)
 
 	// This is the mechanism where the node gives us inforamtion about its
 	// current configuration.
@@ -81,28 +81,28 @@ func (h *Headscale) handlePoll(
 			Bool("readOnly", mapRequest.ReadOnly).
 			Bool("omitPeers", mapRequest.OmitPeers).
 			Bool("stream", mapRequest.Stream).
-			Str("node_key", machine.NodeKey).
-			Str("machine", machine.Hostname).
-			Strs("endpoints", machine.Endpoints).
+			Str("node_key", node.NodeKey).
+			Str("node", node.Hostname).
+			Strs("endpoints", node.Endpoints).
 			Msg("Received endpoint update")
 
 		now := time.Now().UTC()
-		machine.LastSeen = &now
-		machine.Hostname = mapRequest.Hostinfo.Hostname
-		machine.HostInfo = types.HostInfo(*mapRequest.Hostinfo)
-		machine.DiscoKey = util.DiscoPublicKeyStripPrefix(mapRequest.DiscoKey)
-		machine.Endpoints = mapRequest.Endpoints
-
-		if err := h.db.MachineSave(machine); err != nil {
-			logErr(err, "Failed to persist/update machine in the database")
+		node.LastSeen = &now
+		node.Hostname = mapRequest.Hostinfo.Hostname
+		node.HostInfo = types.HostInfo(*mapRequest.Hostinfo)
+		node.DiscoKey = util.DiscoPublicKeyStripPrefix(mapRequest.DiscoKey)
+		node.Endpoints = mapRequest.Endpoints
+
+		if err := h.db.NodeSave(node); err != nil {
+			logErr(err, "Failed to persist/update node in the database")
 			http.Error(writer, "", http.StatusInternalServerError)
 
 			return
 		}
 
-		err := h.db.SaveMachineRoutes(machine)
+		err := h.db.SaveNodeRoutes(node)
 		if err != nil {
-			logErr(err, "Error processing machine routes")
+			logErr(err, "Error processing node routes")
 			http.Error(writer, "", http.StatusInternalServerError)
 
 			return
@@ -111,9 +111,9 @@ func (h *Headscale) handlePoll(
 		h.nodeNotifier.NotifyWithIgnore(
 			types.StateUpdate{
 				Type:    types.StatePeerChanged,
-				Changed: types.Machines{machine},
+				Changed: types.Nodes{node},
 			},
-			machine.MachineKey)
+			node.MachineKey)
 
 		writer.WriteHeader(http.StatusOK)
 		if f, ok := writer.(http.Flusher); ok {
@@ -130,7 +130,7 @@ func (h *Headscale) handlePoll(
 		// The intended use is for clients to discover the DERP map at
 		// start-up before their first real endpoint update.
 	} else if mapRequest.OmitPeers && !mapRequest.Stream && mapRequest.ReadOnly {
-		h.handleLiteRequest(writer, machine, mapRequest, isNoise)
+		h.handleLiteRequest(writer, node, mapRequest, isNoise)
 
 		return
 	} else if mapRequest.OmitPeers && mapRequest.Stream {
@@ -143,23 +143,23 @@ func (h *Headscale) handlePoll(
 	// TODO(kradalby): I am not sure if this has any function based on
 	// incoming requests from clients.
 	if mapRequest.ReadOnly && !mapRequest.Stream {
-		h.handleReadOnly(writer, machine, mapRequest, isNoise)
+		h.handleReadOnly(writer, node, mapRequest, isNoise)
 
 		return
 	}
 
 	now := time.Now().UTC()
-	machine.LastSeen = &now
-	machine.Hostname = mapRequest.Hostinfo.Hostname
-	machine.HostInfo = types.HostInfo(*mapRequest.Hostinfo)
-	machine.DiscoKey = util.DiscoPublicKeyStripPrefix(mapRequest.DiscoKey)
-	machine.Endpoints = mapRequest.Endpoints
+	node.LastSeen = &now
+	node.Hostname = mapRequest.Hostinfo.Hostname
+	node.HostInfo = types.HostInfo(*mapRequest.Hostinfo)
+	node.DiscoKey = util.DiscoPublicKeyStripPrefix(mapRequest.DiscoKey)
+	node.Endpoints = mapRequest.Endpoints
 
 	// When a node connects to control, list the peers it has at
 	// that given point, further updates are kept in memory in
 	// the Mapper, which lives for the duration of the polling
 	// session.
-	peers, err := h.db.ListPeers(machine)
+	peers, err := h.db.ListPeers(node)
 	if err != nil {
 		logErr(err, "Failed to list peers when opening poller")
 		http.Error(writer, "", http.StatusInternalServerError)
@@ -168,7 +168,7 @@ func (h *Headscale) handlePoll(
 	}
 
 	mapp := mapper.NewMapper(
-		machine,
+		node,
 		peers,
 		h.privateKey2019,
 		isNoise,
@@ -179,23 +179,23 @@ func (h *Headscale) handlePoll(
 		h.cfg.RandomizeClientPort,
 	)
 
-	err = h.db.SaveMachineRoutes(machine)
+	err = h.db.SaveNodeRoutes(node)
 	if err != nil {
-		logErr(err, "Error processing machine routes")
+		logErr(err, "Error processing node routes")
 	}
 
 	// update ACLRules with peer informations (to update server tags if necessary)
 	if h.ACLPolicy != nil {
 		// update routes with peer information
-		err = h.db.EnableAutoApprovedRoutes(h.ACLPolicy, machine)
+		err = h.db.EnableAutoApprovedRoutes(h.ACLPolicy, node)
 		if err != nil {
 			logErr(err, "Error running auto approved routes")
 		}
 	}
 
 	// TODO(kradalby): Save specific stuff, not whole object.
-	if err := h.db.MachineSave(machine); err != nil {
-		logErr(err, "Failed to persist/update machine in the database")
+	if err := h.db.NodeSave(node); err != nil {
+		logErr(err, "Failed to persist/update node in the database")
 		http.Error(writer, "", http.StatusInternalServerError)
 
 		return
@@ -203,7 +203,7 @@ func (h *Headscale) handlePoll(
 
 	logInfo("Sending initial map")
 
-	mapResp, err := mapp.FullMapResponse(mapRequest, machine, h.ACLPolicy)
+	mapResp, err := mapp.FullMapResponse(mapRequest, node, h.ACLPolicy)
 	if err != nil {
 		logErr(err, "Failed to create MapResponse")
 		http.Error(writer, "", http.StatusInternalServerError)
@@ -228,24 +228,24 @@ func (h *Headscale) handlePoll(
 	h.nodeNotifier.NotifyWithIgnore(
 		types.StateUpdate{
 			Type:    types.StatePeerChanged,
-			Changed: types.Machines{machine},
+			Changed: types.Nodes{node},
 		},
-		machine.MachineKey)
+		node.MachineKey)
 
 	// Set up the client stream
 	h.pollNetMapStreamWG.Add(1)
 	defer h.pollNetMapStreamWG.Done()
 
 	updateChan := make(chan types.StateUpdate)
-	defer closeChanWithLog(updateChan, machine.Hostname, "updateChan")
+	defer closeChanWithLog(updateChan, node.Hostname, "updateChan")
 
 	// Register the node's update channel
-	h.nodeNotifier.AddNode(machine.MachineKey, updateChan)
-	defer h.nodeNotifier.RemoveNode(machine.MachineKey)
+	h.nodeNotifier.AddNode(node.MachineKey, updateChan)
+	defer h.nodeNotifier.RemoveNode(node.MachineKey)
 
 	keepAliveTicker := time.NewTicker(keepAliveInterval)
 
-	ctx = context.WithValue(ctx, machineNameContextKey, machine.Hostname)
+	ctx = context.WithValue(ctx, nodeNameContextKey, node.Hostname)
 
 	ctx, cancel := context.WithCancel(ctx)
 	defer cancel()
@@ -254,7 +254,7 @@ func (h *Headscale) handlePoll(
 		logInfo("Waiting for update on stream channel")
 		select {
 		case <-keepAliveTicker.C:
-			data, err := mapp.KeepAliveResponse(mapRequest, machine)
+			data, err := mapp.KeepAliveResponse(mapRequest, node)
 			if err != nil {
 				logErr(err, "Error generating the keep alive msg")
 
@@ -280,9 +280,9 @@ func (h *Headscale) handlePoll(
 			// goroutines, but then you might have a problem without a lock
 			// if a keepalive is written at the same time as an update.
 			go func() {
-				err = h.db.UpdateLastSeen(machine)
+				err = h.db.UpdateLastSeen(node)
 				if err != nil {
-					logErr(err, "Cannot update machine LastSeen")
+					logErr(err, "Cannot update node LastSeen")
 
 					return
 				}
@@ -298,16 +298,16 @@ func (h *Headscale) handlePoll(
 			switch update.Type {
 			case types.StatePeerChanged:
 				logInfo("Sending PeerChanged MapResponse")
-				data, err = mapp.PeerChangedResponse(mapRequest, machine, update.Changed, h.ACLPolicy)
+				data, err = mapp.PeerChangedResponse(mapRequest, node, update.Changed, h.ACLPolicy)
 			case types.StatePeerRemoved:
 				logInfo("Sending PeerRemoved MapResponse")
-				data, err = mapp.PeerRemovedResponse(mapRequest, machine, update.Removed)
+				data, err = mapp.PeerRemovedResponse(mapRequest, node, update.Removed)
 			case types.StateDERPUpdated:
 				logInfo("Sending DERPUpdate MapResponse")
-				data, err = mapp.DERPMapResponse(mapRequest, machine, update.DERPMap)
+				data, err = mapp.DERPMapResponse(mapRequest, node, update.DERPMap)
 			case types.StateFullUpdate:
 				logInfo("Sending Full MapResponse")
-				data, err = mapp.FullMapResponse(mapRequest, machine, h.ACLPolicy)
+				data, err = mapp.FullMapResponse(mapRequest, node, h.ACLPolicy)
 			}
 
 			if err != nil {
@@ -320,7 +320,7 @@ func (h *Headscale) handlePoll(
 			if err != nil {
 				logErr(err, "Could not write the map response")
 
-				updateRequestsSentToNode.WithLabelValues(machine.User.Name, machine.Hostname, "failed").
+				updateRequestsSentToNode.WithLabelValues(node.User.Name, node.Hostname, "failed").
 					Inc()
 
 				return
@@ -336,9 +336,9 @@ func (h *Headscale) handlePoll(
 
 			// See comment in keepAliveTicker
 			go func() {
-				err = h.db.UpdateLastSeen(machine)
+				err = h.db.UpdateLastSeen(node)
 				if err != nil {
-					logErr(err, "Cannot update machine LastSeen")
+					logErr(err, "Cannot update node LastSeen")
 
 					return
 				}
@@ -350,17 +350,17 @@ func (h *Headscale) handlePoll(
 				Bool("readOnly", mapRequest.ReadOnly).
 				Bool("omitPeers", mapRequest.OmitPeers).
 				Bool("stream", mapRequest.Stream).
-				Str("node_key", machine.NodeKey).
-				Str("machine", machine.Hostname).
+				Str("node_key", node.NodeKey).
+				Str("node", node.Hostname).
 				TimeDiff("timeSpent", time.Now(), now).
 				Msg("update sent")
 		case <-ctx.Done():
 			logInfo("The client has closed the connection")
 
 			go func() {
-				err = h.db.UpdateLastSeen(machine)
+				err = h.db.UpdateLastSeen(node)
 				if err != nil {
-					logErr(err, "Cannot update machine LastSeen")
+					logErr(err, "Cannot update node LastSeen")
 
 					return
 				}
@@ -377,10 +377,10 @@ func (h *Headscale) handlePoll(
 	}
 }
 
-func closeChanWithLog[C chan []byte | chan struct{} | chan types.StateUpdate](channel C, machine, name string) {
+func closeChanWithLog[C chan []byte | chan struct{} | chan types.StateUpdate](channel C, node, name string) {
 	log.Trace().
 		Str("handler", "PollNetMap").
-		Str("machine", machine).
+		Str("node", node).
 		Str("channel", "Done").
 		Msg(fmt.Sprintf("Closing %s channel", name))
 
@@ -392,17 +392,17 @@ func closeChanWithLog[C chan []byte | chan struct{} | chan types.StateUpdate](ch
 // is not.
 func (h *Headscale) handleReadOnly(
 	writer http.ResponseWriter,
-	machine *types.Machine,
+	node *types.Node,
 	mapRequest tailcfg.MapRequest,
 	isNoise bool,
 ) {
-	logInfo, logErr := logPollFunc(mapRequest, machine, isNoise)
+	logInfo, logErr := logPollFunc(mapRequest, node, isNoise)
 
 	mapp := mapper.NewMapper(
-		machine,
+		node,
 		// TODO(kradalby): It might not be acceptable to send
 		// an empty peer list here.
-		types.Machines{},
+		types.Nodes{},
 		h.privateKey2019,
 		isNoise,
 		h.DERPMap,
@@ -413,7 +413,7 @@ func (h *Headscale) handleReadOnly(
 	)
 	logInfo("Client is starting up. Probably interested in a DERP map")
 
-	mapResp, err := mapp.FullMapResponse(mapRequest, machine, h.ACLPolicy)
+	mapResp, err := mapp.FullMapResponse(mapRequest, node, h.ACLPolicy)
 	if err != nil {
 		logErr(err, "Failed to create MapResponse")
 		http.Error(writer, "", http.StatusInternalServerError)
@@ -435,17 +435,17 @@ func (h *Headscale) handleReadOnly(
 
 func (h *Headscale) handleLiteRequest(
 	writer http.ResponseWriter,
-	machine *types.Machine,
+	node *types.Node,
 	mapRequest tailcfg.MapRequest,
 	isNoise bool,
 ) {
-	logInfo, logErr := logPollFunc(mapRequest, machine, isNoise)
+	logInfo, logErr := logPollFunc(mapRequest, node, isNoise)
 
 	mapp := mapper.NewMapper(
-		machine,
+		node,
 		// TODO(kradalby): It might not be acceptable to send
 		// an empty peer list here.
-		types.Machines{},
+		types.Nodes{},
 		h.privateKey2019,
 		isNoise,
 		h.DERPMap,
@@ -457,7 +457,7 @@ func (h *Headscale) handleLiteRequest(
 
 	logInfo("Client asked for a lite update, responding without peers")
 
-	mapResp, err := mapp.LiteMapResponse(mapRequest, machine, h.ACLPolicy)
+	mapResp, err := mapp.LiteMapResponse(mapRequest, node, h.ACLPolicy)
 	if err != nil {
 		logErr(err, "Failed to create MapResponse")
 		http.Error(writer, "", http.StatusInternalServerError)
diff --git a/hscontrol/poll_legacy.go b/hscontrol/poll_legacy.go
index 90cb13201f..fe004848f6 100644
--- a/hscontrol/poll_legacy.go
+++ b/hscontrol/poll_legacy.go
@@ -68,12 +68,12 @@ func (h *Headscale) PollNetMapHandler(
 		return
 	}
 
-	machine, err := h.db.GetMachineByMachineKey(machineKey)
+	node, err := h.db.GetNodeByMachineKey(machineKey)
 	if err != nil {
 		if errors.Is(err, gorm.ErrRecordNotFound) {
 			log.Warn().
 				Str("handler", "PollNetMap").
-				Msgf("Ignoring request, cannot find machine with key %s", machineKey.String())
+				Msgf("Ignoring request, cannot find node with key %s", machineKey.String())
 
 			http.Error(writer, "", http.StatusUnauthorized)
 
@@ -81,7 +81,7 @@ func (h *Headscale) PollNetMapHandler(
 		}
 		log.Error().
 			Str("handler", "PollNetMap").
-			Msgf("Failed to fetch machine from the database with Machine key: %s", machineKey.String())
+			Msgf("Failed to fetch node from the database with Machine key: %s", machineKey.String())
 		http.Error(writer, "", http.StatusInternalServerError)
 
 		return
@@ -90,8 +90,8 @@ func (h *Headscale) PollNetMapHandler(
 	log.Trace().
 		Str("handler", "PollNetMap").
 		Str("id", machineKeyStr).
-		Str("machine", machine.Hostname).
-		Msg("A machine is sending a MapRequest via legacy protocol")
+		Str("node", node.Hostname).
+		Msg("A node is sending a MapRequest via legacy protocol")
 
-	h.handlePoll(writer, req.Context(), machine, mapRequest, false)
+	h.handlePoll(writer, req.Context(), node, mapRequest, false)
 }
diff --git a/hscontrol/poll_noise.go b/hscontrol/poll_noise.go
index 3d672f0b6b..c7b6b80501 100644
--- a/hscontrol/poll_noise.go
+++ b/hscontrol/poll_noise.go
@@ -49,7 +49,7 @@ func (ns *noiseServer) NoisePollNetMapHandler(
 
 	ns.nodeKey = mapRequest.NodeKey
 
-	machine, err := ns.headscale.db.GetMachineByAnyKey(
+	node, err := ns.headscale.db.GetNodeByAnyKey(
 		ns.conn.Peer(),
 		mapRequest.NodeKey,
 		key.NodePublic{},
@@ -58,22 +58,22 @@ func (ns *noiseServer) NoisePollNetMapHandler(
 		if errors.Is(err, gorm.ErrRecordNotFound) {
 			log.Warn().
 				Str("handler", "NoisePollNetMap").
-				Msgf("Ignoring request, cannot find machine with key %s", mapRequest.NodeKey.String())
+				Msgf("Ignoring request, cannot find node with key %s", mapRequest.NodeKey.String())
 			http.Error(writer, "Internal error", http.StatusNotFound)
 
 			return
 		}
 		log.Error().
 			Str("handler", "NoisePollNetMap").
-			Msgf("Failed to fetch machine from the database with node key: %s", mapRequest.NodeKey.String())
+			Msgf("Failed to fetch node from the database with node key: %s", mapRequest.NodeKey.String())
 		http.Error(writer, "Internal error", http.StatusInternalServerError)
 
 		return
 	}
 	log.Debug().
 		Str("handler", "NoisePollNetMap").
-		Str("machine", machine.Hostname).
-		Msg("A machine sending a MapRequest with Noise protocol")
+		Str("node", node.Hostname).
+		Msg("A node sending a MapRequest with Noise protocol")
 
-	ns.headscale.handlePoll(writer, req.Context(), machine, mapRequest, true)
+	ns.headscale.handlePoll(writer, req.Context(), node, mapRequest, true)
 }
diff --git a/hscontrol/types/common.go b/hscontrol/types/common.go
index e80ef8f4cb..b275fa4ad2 100644
--- a/hscontrol/types/common.go
+++ b/hscontrol/types/common.go
@@ -28,7 +28,7 @@ func (hi *HostInfo) Scan(destination interface{}) error {
 		return json.Unmarshal([]byte(value), hi)
 
 	default:
-		return fmt.Errorf("%w: unexpected data type %T", ErrMachineAddressesInvalid, destination)
+		return fmt.Errorf("%w: unexpected data type %T", ErrNodeAddressesInvalid, destination)
 	}
 }
 
@@ -74,7 +74,7 @@ func (i *IPPrefixes) Scan(destination interface{}) error {
 		return json.Unmarshal([]byte(value), i)
 
 	default:
-		return fmt.Errorf("%w: unexpected data type %T", ErrMachineAddressesInvalid, destination)
+		return fmt.Errorf("%w: unexpected data type %T", ErrNodeAddressesInvalid, destination)
 	}
 }
 
@@ -96,7 +96,7 @@ func (i *StringList) Scan(destination interface{}) error {
 		return json.Unmarshal([]byte(value), i)
 
 	default:
-		return fmt.Errorf("%w: unexpected data type %T", ErrMachineAddressesInvalid, destination)
+		return fmt.Errorf("%w: unexpected data type %T", ErrNodeAddressesInvalid, destination)
 	}
 }
 
@@ -123,8 +123,8 @@ type StateUpdate struct {
 	Type StateUpdateType
 
 	// Changed must be set when Type is StatePeerChanged and
-	// contain the Machine IDs of machines that has changed.
-	Changed Machines
+	// contain the Node IDs of nodes that have changed.
+	Changed Nodes
 
 	// Removed must be set when Type is StatePeerRemoved and
 	// contain a list of the nodes that has been removed from
diff --git a/hscontrol/types/machine.go b/hscontrol/types/machine.go
deleted file mode 100644
index 534a0d13a5..0000000000
--- a/hscontrol/types/machine.go
+++ /dev/null
@@ -1,346 +0,0 @@
-package types
-
-import (
-	"database/sql/driver"
-	"errors"
-	"fmt"
-	"net/netip"
-	"sort"
-	"strings"
-	"time"
-
-	v1 "github.com/juanfont/headscale/gen/go/headscale/v1"
-	"github.com/juanfont/headscale/hscontrol/policy/matcher"
-	"github.com/juanfont/headscale/hscontrol/util"
-	"go4.org/netipx"
-	"google.golang.org/protobuf/types/known/timestamppb"
-	"tailscale.com/tailcfg"
-	"tailscale.com/types/key"
-)
-
-var (
-	ErrMachineAddressesInvalid = errors.New("failed to parse machine addresses")
-	ErrHostnameTooLong         = errors.New("hostname too long")
-)
-
-// Machine is a Headscale client.
-type Machine struct {
-	ID          uint64 `gorm:"primary_key"`
-	MachineKey  string `gorm:"type:varchar(64);unique_index"`
-	NodeKey     string
-	DiscoKey    string
-	IPAddresses MachineAddresses
-
-	// Hostname represents the name given by the Tailscale
-	// client during registration
-	Hostname string
-
-	// Givenname represents either:
-	// a DNS normalized version of Hostname
-	// a valid name set by the User
-	//
-	// GivenName is the name used in all DNS related
-	// parts of headscale.
-	GivenName string `gorm:"type:varchar(63);unique_index"`
-	UserID    uint
-	User      User `gorm:"foreignKey:UserID"`
-
-	RegisterMethod string
-
-	ForcedTags StringList
-
-	// TODO(kradalby): This seems like irrelevant information?
-	AuthKeyID uint
-	AuthKey   *PreAuthKey
-
-	LastSeen *time.Time
-	Expiry   *time.Time
-
-	HostInfo  HostInfo
-	Endpoints StringList
-
-	Routes []Route
-
-	CreatedAt time.Time
-	UpdatedAt time.Time
-	DeletedAt *time.Time
-}
-
-type (
-	Machines []*Machine
-)
-
-type MachineAddresses []netip.Addr
-
-func (ma MachineAddresses) Sort() {
-	sort.Slice(ma, func(index1, index2 int) bool {
-		if ma[index1].Is4() && ma[index2].Is6() {
-			return true
-		}
-		if ma[index1].Is6() && ma[index2].Is4() {
-			return false
-		}
-
-		return ma[index1].Compare(ma[index2]) < 0
-	})
-}
-
-func (ma MachineAddresses) StringSlice() []string {
-	ma.Sort()
-	strSlice := make([]string, 0, len(ma))
-	for _, addr := range ma {
-		strSlice = append(strSlice, addr.String())
-	}
-
-	return strSlice
-}
-
-func (ma MachineAddresses) Prefixes() []netip.Prefix {
-	addrs := []netip.Prefix{}
-	for _, machineAddress := range ma {
-		ip := netip.PrefixFrom(machineAddress, machineAddress.BitLen())
-		addrs = append(addrs, ip)
-	}
-
-	return addrs
-}
-
-func (ma MachineAddresses) InIPSet(set *netipx.IPSet) bool {
-	for _, machineAddr := range ma {
-		if set.Contains(machineAddr) {
-			return true
-		}
-	}
-
-	return false
-}
-
-// AppendToIPSet adds the individual ips in MachineAddresses to a
-// given netipx.IPSetBuilder.
-func (ma MachineAddresses) AppendToIPSet(build *netipx.IPSetBuilder) {
-	for _, ip := range ma {
-		build.Add(ip)
-	}
-}
-
-func (ma *MachineAddresses) Scan(destination interface{}) error {
-	switch value := destination.(type) {
-	case string:
-		addresses := strings.Split(value, ",")
-		*ma = (*ma)[:0]
-		for _, addr := range addresses {
-			if len(addr) < 1 {
-				continue
-			}
-			parsed, err := netip.ParseAddr(addr)
-			if err != nil {
-				return err
-			}
-			*ma = append(*ma, parsed)
-		}
-
-		return nil
-
-	default:
-		return fmt.Errorf("%w: unexpected data type %T", ErrMachineAddressesInvalid, destination)
-	}
-}
-
-// Value return json value, implement driver.Valuer interface.
-func (ma MachineAddresses) Value() (driver.Value, error) {
-	addresses := strings.Join(ma.StringSlice(), ",")
-
-	return addresses, nil
-}
-
-// IsExpired returns whether the machine registration has expired.
-func (machine Machine) IsExpired() bool {
-	// If Expiry is not set, the client has not indicated that
-	// it wants an expiry time, it is therefor considered
-	// to mean "not expired"
-	if machine.Expiry == nil || machine.Expiry.IsZero() {
-		return false
-	}
-
-	return time.Now().UTC().After(*machine.Expiry)
-}
-
-// IsOnline returns if the machine is connected to Headscale.
-// This is really a naive implementation, as we don't really see
-// if there is a working connection between the client and the server.
-func (machine *Machine) IsOnline() bool {
-	if machine.LastSeen == nil {
-		return false
-	}
-
-	if machine.IsExpired() {
-		return false
-	}
-
-	return machine.LastSeen.After(time.Now().Add(-KeepAliveInterval))
-}
-
-// IsEphemeral returns if the machine is registered as an Ephemeral node.
-// https://tailscale.com/kb/1111/ephemeral-nodes/
-func (machine *Machine) IsEphemeral() bool {
-	return machine.AuthKey != nil && machine.AuthKey.Ephemeral
-}
-
-func (machine *Machine) CanAccess(filter []tailcfg.FilterRule, machine2 *Machine) bool {
-	for _, rule := range filter {
-		// TODO(kradalby): Cache or pregen this
-		matcher := matcher.MatchFromFilterRule(rule)
-
-		if !matcher.SrcsContainsIPs([]netip.Addr(machine.IPAddresses)) {
-			continue
-		}
-
-		if matcher.DestsContainsIP([]netip.Addr(machine2.IPAddresses)) {
-			return true
-		}
-	}
-
-	return false
-}
-
-func (machines Machines) FilterByIP(ip netip.Addr) Machines {
-	found := make(Machines, 0)
-
-	for _, machine := range machines {
-		for _, mIP := range machine.IPAddresses {
-			if ip == mIP {
-				found = append(found, machine)
-			}
-		}
-	}
-
-	return found
-}
-
-func (machine *Machine) Proto() *v1.Machine {
-	machineProto := &v1.Machine{
-		Id:         machine.ID,
-		MachineKey: machine.MachineKey,
-
-		NodeKey:     machine.NodeKey,
-		DiscoKey:    machine.DiscoKey,
-		IpAddresses: machine.IPAddresses.StringSlice(),
-		Name:        machine.Hostname,
-		GivenName:   machine.GivenName,
-		User:        machine.User.Proto(),
-		ForcedTags:  machine.ForcedTags,
-		Online:      machine.IsOnline(),
-
-		// TODO(kradalby): Implement register method enum converter
-		// RegisterMethod: ,
-
-		CreatedAt: timestamppb.New(machine.CreatedAt),
-	}
-
-	if machine.AuthKey != nil {
-		machineProto.PreAuthKey = machine.AuthKey.Proto()
-	}
-
-	if machine.LastSeen != nil {
-		machineProto.LastSeen = timestamppb.New(*machine.LastSeen)
-	}
-
-	if machine.Expiry != nil {
-		machineProto.Expiry = timestamppb.New(*machine.Expiry)
-	}
-
-	return machineProto
-}
-
-// GetHostInfo returns a Hostinfo struct for the machine.
-func (machine *Machine) GetHostInfo() tailcfg.Hostinfo {
-	return tailcfg.Hostinfo(machine.HostInfo)
-}
-
-func (machine *Machine) GetFQDN(dnsConfig *tailcfg.DNSConfig, baseDomain string) (string, error) {
-	var hostname string
-	if dnsConfig != nil && dnsConfig.Proxied { // MagicDNS
-		hostname = fmt.Sprintf(
-			"%s.%s.%s",
-			machine.GivenName,
-			machine.User.Name,
-			baseDomain,
-		)
-		if len(hostname) > MaxHostnameLength {
-			return "", fmt.Errorf(
-				"hostname %q is too long it cannot except 255 ASCII chars: %w",
-				hostname,
-				ErrHostnameTooLong,
-			)
-		}
-	} else {
-		hostname = machine.GivenName
-	}
-
-	return hostname, nil
-}
-
-func (machine *Machine) MachinePublicKey() (key.MachinePublic, error) {
-	var machineKey key.MachinePublic
-
-	if machine.MachineKey != "" {
-		err := machineKey.UnmarshalText(
-			[]byte(util.MachinePublicKeyEnsurePrefix(machine.MachineKey)),
-		)
-		if err != nil {
-			return key.MachinePublic{}, fmt.Errorf("failed to parse machine public key: %w", err)
-		}
-	}
-
-	return machineKey, nil
-}
-
-func (machine *Machine) DiscoPublicKey() (key.DiscoPublic, error) {
-	var discoKey key.DiscoPublic
-	if machine.DiscoKey != "" {
-		err := discoKey.UnmarshalText(
-			[]byte(util.DiscoPublicKeyEnsurePrefix(machine.DiscoKey)),
-		)
-		if err != nil {
-			return key.DiscoPublic{}, fmt.Errorf("failed to parse disco public key: %w", err)
-		}
-	} else {
-		discoKey = key.DiscoPublic{}
-	}
-
-	return discoKey, nil
-}
-
-func (machine *Machine) NodePublicKey() (key.NodePublic, error) {
-	var nodeKey key.NodePublic
-	err := nodeKey.UnmarshalText([]byte(util.NodePublicKeyEnsurePrefix(machine.NodeKey)))
-	if err != nil {
-		return key.NodePublic{}, fmt.Errorf("failed to parse node public key: %w", err)
-	}
-
-	return nodeKey, nil
-}
-
-func (machine Machine) String() string {
-	return machine.Hostname
-}
-
-func (machines Machines) String() string {
-	temp := make([]string, len(machines))
-
-	for index, machine := range machines {
-		temp[index] = machine.Hostname
-	}
-
-	return fmt.Sprintf("[ %s ](%d)", strings.Join(temp, ", "), len(temp))
-}
-
-func (machines Machines) IDMap() map[uint64]*Machine {
-	ret := map[uint64]*Machine{}
-
-	for _, machine := range machines {
-		ret[machine.ID] = machine
-	}
-
-	return ret
-}
diff --git a/hscontrol/types/node.go b/hscontrol/types/node.go
new file mode 100644
index 0000000000..f8af2338e7
--- /dev/null
+++ b/hscontrol/types/node.go
@@ -0,0 +1,346 @@
+package types
+
+import (
+	"database/sql/driver"
+	"errors"
+	"fmt"
+	"net/netip"
+	"sort"
+	"strings"
+	"time"
+
+	v1 "github.com/juanfont/headscale/gen/go/headscale/v1"
+	"github.com/juanfont/headscale/hscontrol/policy/matcher"
+	"github.com/juanfont/headscale/hscontrol/util"
+	"go4.org/netipx"
+	"google.golang.org/protobuf/types/known/timestamppb"
+	"tailscale.com/tailcfg"
+	"tailscale.com/types/key"
+)
+
+var (
+	ErrNodeAddressesInvalid = errors.New("failed to parse node addresses")
+	ErrHostnameTooLong      = errors.New("hostname too long")
+)
+
+// Node is a Headscale client.
+type Node struct {
+	ID          uint64 `gorm:"primary_key"`
+	MachineKey  string `gorm:"type:varchar(64);unique_index"`
+	NodeKey     string
+	DiscoKey    string
+	IPAddresses NodeAddresses
+
+	// Hostname represents the name given by the Tailscale
+	// client during registration
+	Hostname string
+
+	// Givenname represents either:
+	// a DNS normalized version of Hostname
+	// a valid name set by the User
+	//
+	// GivenName is the name used in all DNS related
+	// parts of headscale.
+	GivenName string `gorm:"type:varchar(63);unique_index"`
+	UserID    uint
+	User      User `gorm:"foreignKey:UserID"`
+
+	RegisterMethod string
+
+	ForcedTags StringList
+
+	// TODO(kradalby): This seems like irrelevant information?
+	AuthKeyID uint
+	AuthKey   *PreAuthKey
+
+	LastSeen *time.Time
+	Expiry   *time.Time
+
+	HostInfo  HostInfo
+	Endpoints StringList
+
+	Routes []Route
+
+	CreatedAt time.Time
+	UpdatedAt time.Time
+	DeletedAt *time.Time
+}
+
+type (
+	Nodes []*Node
+)
+
+type NodeAddresses []netip.Addr
+
+func (na NodeAddresses) Sort() {
+	sort.Slice(na, func(index1, index2 int) bool {
+		if na[index1].Is4() && na[index2].Is6() {
+			return true
+		}
+		if na[index1].Is6() && na[index2].Is4() {
+			return false
+		}
+
+		return na[index1].Compare(na[index2]) < 0
+	})
+}
+
+func (na NodeAddresses) StringSlice() []string {
+	na.Sort()
+	strSlice := make([]string, 0, len(na))
+	for _, addr := range na {
+		strSlice = append(strSlice, addr.String())
+	}
+
+	return strSlice
+}
+
+func (na NodeAddresses) Prefixes() []netip.Prefix {
+	addrs := []netip.Prefix{}
+	for _, nodeAddress := range na {
+		ip := netip.PrefixFrom(nodeAddress, nodeAddress.BitLen())
+		addrs = append(addrs, ip)
+	}
+
+	return addrs
+}
+
+func (na NodeAddresses) InIPSet(set *netipx.IPSet) bool {
+	for _, nodeAddr := range na {
+		if set.Contains(nodeAddr) {
+			return true
+		}
+	}
+
+	return false
+}
+
+// AppendToIPSet adds the individual ips in NodeAddresses to a
+// given netipx.IPSetBuilder.
+func (na NodeAddresses) AppendToIPSet(build *netipx.IPSetBuilder) {
+	for _, ip := range na {
+		build.Add(ip)
+	}
+}
+
+func (na *NodeAddresses) Scan(destination interface{}) error {
+	switch value := destination.(type) {
+	case string:
+		addresses := strings.Split(value, ",")
+		*na = (*na)[:0]
+		for _, addr := range addresses {
+			if len(addr) < 1 {
+				continue
+			}
+			parsed, err := netip.ParseAddr(addr)
+			if err != nil {
+				return err
+			}
+			*na = append(*na, parsed)
+		}
+
+		return nil
+
+	default:
+		return fmt.Errorf("%w: unexpected data type %T", ErrNodeAddressesInvalid, destination)
+	}
+}
+
+// Value return json value, implement driver.Valuer interface.
+func (na NodeAddresses) Value() (driver.Value, error) {
+	addresses := strings.Join(na.StringSlice(), ",")
+
+	return addresses, nil
+}
+
+// IsExpired returns whether the node registration has expired.
+func (node Node) IsExpired() bool {
+	// If Expiry is not set, the client has not indicated that
+	// it wants an expiry time, it is therefor considered
+	// to mean "not expired"
+	if node.Expiry == nil || node.Expiry.IsZero() {
+		return false
+	}
+
+	return time.Now().UTC().After(*node.Expiry)
+}
+
+// IsOnline returns if the node is connected to Headscale.
+// This is really a naive implementation, as we don't really see
+// if there is a working connection between the client and the server.
+func (node *Node) IsOnline() bool {
+	if node.LastSeen == nil {
+		return false
+	}
+
+	if node.IsExpired() {
+		return false
+	}
+
+	return node.LastSeen.After(time.Now().Add(-KeepAliveInterval))
+}
+
+// IsEphemeral returns if the node is registered as an Ephemeral node.
+// https://tailscale.com/kb/1111/ephemeral-nodes/
+func (node *Node) IsEphemeral() bool {
+	return node.AuthKey != nil && node.AuthKey.Ephemeral
+}
+
+func (node *Node) CanAccess(filter []tailcfg.FilterRule, node2 *Node) bool {
+	for _, rule := range filter {
+		// TODO(kradalby): Cache or pregen this
+		matcher := matcher.MatchFromFilterRule(rule)
+
+		if !matcher.SrcsContainsIPs([]netip.Addr(node.IPAddresses)) {
+			continue
+		}
+
+		if matcher.DestsContainsIP([]netip.Addr(node2.IPAddresses)) {
+			return true
+		}
+	}
+
+	return false
+}
+
+func (nodes Nodes) FilterByIP(ip netip.Addr) Nodes {
+	found := make(Nodes, 0)
+
+	for _, node := range nodes {
+		for _, mIP := range node.IPAddresses {
+			if ip == mIP {
+				found = append(found, node)
+			}
+		}
+	}
+
+	return found
+}
+
+func (node *Node) Proto() *v1.Node {
+	nodeProto := &v1.Node{
+		Id:         node.ID,
+		MachineKey: node.MachineKey,
+
+		NodeKey:     node.NodeKey,
+		DiscoKey:    node.DiscoKey,
+		IpAddresses: node.IPAddresses.StringSlice(),
+		Name:        node.Hostname,
+		GivenName:   node.GivenName,
+		User:        node.User.Proto(),
+		ForcedTags:  node.ForcedTags,
+		Online:      node.IsOnline(),
+
+		// TODO(kradalby): Implement register method enum converter
+		// RegisterMethod: ,
+
+		CreatedAt: timestamppb.New(node.CreatedAt),
+	}
+
+	if node.AuthKey != nil {
+		nodeProto.PreAuthKey = node.AuthKey.Proto()
+	}
+
+	if node.LastSeen != nil {
+		nodeProto.LastSeen = timestamppb.New(*node.LastSeen)
+	}
+
+	if node.Expiry != nil {
+		nodeProto.Expiry = timestamppb.New(*node.Expiry)
+	}
+
+	return nodeProto
+}
+
+// GetHostInfo returns a Hostinfo struct for the node.
+func (node *Node) GetHostInfo() tailcfg.Hostinfo {
+	return tailcfg.Hostinfo(node.HostInfo)
+}
+
+func (node *Node) GetFQDN(dnsConfig *tailcfg.DNSConfig, baseDomain string) (string, error) {
+	var hostname string
+	if dnsConfig != nil && dnsConfig.Proxied { // MagicDNS
+		hostname = fmt.Sprintf(
+			"%s.%s.%s",
+			node.GivenName,
+			node.User.Name,
+			baseDomain,
+		)
+		if len(hostname) > MaxHostnameLength {
+			return "", fmt.Errorf(
+				"hostname %q is too long it cannot except 255 ASCII chars: %w",
+				hostname,
+				ErrHostnameTooLong,
+			)
+		}
+	} else {
+		hostname = node.GivenName
+	}
+
+	return hostname, nil
+}
+
+func (node *Node) MachinePublicKey() (key.MachinePublic, error) {
+	var machineKey key.MachinePublic
+
+	if node.MachineKey != "" {
+		err := machineKey.UnmarshalText(
+			[]byte(util.MachinePublicKeyEnsurePrefix(node.MachineKey)),
+		)
+		if err != nil {
+			return key.MachinePublic{}, fmt.Errorf("failed to parse machine public key: %w", err)
+		}
+	}
+
+	return machineKey, nil
+}
+
+func (node *Node) DiscoPublicKey() (key.DiscoPublic, error) {
+	var discoKey key.DiscoPublic
+	if node.DiscoKey != "" {
+		err := discoKey.UnmarshalText(
+			[]byte(util.DiscoPublicKeyEnsurePrefix(node.DiscoKey)),
+		)
+		if err != nil {
+			return key.DiscoPublic{}, fmt.Errorf("failed to parse disco public key: %w", err)
+		}
+	} else {
+		discoKey = key.DiscoPublic{}
+	}
+
+	return discoKey, nil
+}
+
+func (node *Node) NodePublicKey() (key.NodePublic, error) {
+	var nodeKey key.NodePublic
+	err := nodeKey.UnmarshalText([]byte(util.NodePublicKeyEnsurePrefix(node.NodeKey)))
+	if err != nil {
+		return key.NodePublic{}, fmt.Errorf("failed to parse node public key: %w", err)
+	}
+
+	return nodeKey, nil
+}
+
+func (node Node) String() string {
+	return node.Hostname
+}
+
+func (nodes Nodes) String() string {
+	temp := make([]string, len(nodes))
+
+	for index, node := range nodes {
+		temp[index] = node.Hostname
+	}
+
+	return fmt.Sprintf("[ %s ](%d)", strings.Join(temp, ", "), len(temp))
+}
+
+func (nodes Nodes) IDMap() map[uint64]*Node {
+	ret := map[uint64]*Node{}
+
+	for _, node := range nodes {
+		ret[node.ID] = node
+	}
+
+	return ret
+}
diff --git a/hscontrol/types/machine_test.go b/hscontrol/types/node_test.go
similarity index 83%
rename from hscontrol/types/machine_test.go
rename to hscontrol/types/node_test.go
index f57f8a33a9..85fa79c44b 100644
--- a/hscontrol/types/machine_test.go
+++ b/hscontrol/types/node_test.go
@@ -7,20 +7,20 @@ import (
 	"tailscale.com/tailcfg"
 )
 
-func Test_MachineCanAccess(t *testing.T) {
+func Test_NodeCanAccess(t *testing.T) {
 	tests := []struct {
-		name     string
-		machine1 Machine
-		machine2 Machine
-		rules    []tailcfg.FilterRule
-		want     bool
+		name  string
+		node1 Node
+		node2 Node
+		rules []tailcfg.FilterRule
+		want  bool
 	}{
 		{
 			name: "no-rules",
-			machine1: Machine{
+			node1: Node{
 				IPAddresses: []netip.Addr{netip.MustParseAddr("10.0.0.1")},
 			},
-			machine2: Machine{
+			node2: Node{
 				IPAddresses: []netip.Addr{netip.MustParseAddr("10.0.0.2")},
 			},
 			rules: []tailcfg.FilterRule{},
@@ -28,10 +28,10 @@ func Test_MachineCanAccess(t *testing.T) {
 		},
 		{
 			name: "wildcard",
-			machine1: Machine{
+			node1: Node{
 				IPAddresses: []netip.Addr{netip.MustParseAddr("10.0.0.1")},
 			},
-			machine2: Machine{
+			node2: Node{
 				IPAddresses: []netip.Addr{netip.MustParseAddr("10.0.0.2")},
 			},
 			rules: []tailcfg.FilterRule{
@@ -49,10 +49,10 @@ func Test_MachineCanAccess(t *testing.T) {
 		},
 		{
 			name: "other-cant-access-src",
-			machine1: Machine{
+			node1: Node{
 				IPAddresses: []netip.Addr{netip.MustParseAddr("100.64.0.1")},
 			},
-			machine2: Machine{
+			node2: Node{
 				IPAddresses: []netip.Addr{netip.MustParseAddr("100.64.0.3")},
 			},
 			rules: []tailcfg.FilterRule{
@@ -67,10 +67,10 @@ func Test_MachineCanAccess(t *testing.T) {
 		},
 		{
 			name: "dest-cant-access-src",
-			machine1: Machine{
+			node1: Node{
 				IPAddresses: []netip.Addr{netip.MustParseAddr("100.64.0.3")},
 			},
-			machine2: Machine{
+			node2: Node{
 				IPAddresses: []netip.Addr{netip.MustParseAddr("100.64.0.2")},
 			},
 			rules: []tailcfg.FilterRule{
@@ -85,10 +85,10 @@ func Test_MachineCanAccess(t *testing.T) {
 		},
 		{
 			name: "src-can-access-dest",
-			machine1: Machine{
+			node1: Node{
 				IPAddresses: []netip.Addr{netip.MustParseAddr("100.64.0.2")},
 			},
-			machine2: Machine{
+			node2: Node{
 				IPAddresses: []netip.Addr{netip.MustParseAddr("100.64.0.3")},
 			},
 			rules: []tailcfg.FilterRule{
@@ -105,7 +105,7 @@ func Test_MachineCanAccess(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			got := tt.machine1.CanAccess(tt.rules, &tt.machine2)
+			got := tt.node1.CanAccess(tt.rules, &tt.node2)
 
 			if got != tt.want {
 				t.Errorf("canAccess() failed: want (%t), got (%t)", tt.want, got)
@@ -114,8 +114,8 @@ func Test_MachineCanAccess(t *testing.T) {
 	}
 }
 
-func TestMachineAddressesOrder(t *testing.T) {
-	machineAddresses := MachineAddresses{
+func TestNodeAddressesOrder(t *testing.T) {
+	machineAddresses := NodeAddresses{
 		netip.MustParseAddr("2001:db8::2"),
 		netip.MustParseAddr("100.64.0.2"),
 		netip.MustParseAddr("2001:db8::1"),
diff --git a/hscontrol/types/routes.go b/hscontrol/types/routes.go
index 1f430712dc..3fd96702e2 100644
--- a/hscontrol/types/routes.go
+++ b/hscontrol/types/routes.go
@@ -17,9 +17,9 @@ var (
 type Route struct {
 	gorm.Model
 
-	MachineID uint64
-	Machine   Machine
-	Prefix    IPPrefix
+	NodeID uint64
+	Node   Node
+	Prefix IPPrefix
 
 	Advertised bool
 	Enabled    bool
@@ -29,7 +29,7 @@ type Route struct {
 type Routes []Route
 
 func (r *Route) String() string {
-	return fmt.Sprintf("%s:%s", r.Machine, netip.Prefix(r.Prefix).String())
+	return fmt.Sprintf("%s:%s", r.Node, netip.Prefix(r.Prefix).String())
 }
 
 func (r *Route) IsExitRoute() bool {
@@ -51,7 +51,7 @@ func (rs Routes) Proto() []*v1.Route {
 	for _, route := range rs {
 		protoRoute := v1.Route{
 			Id:         uint64(route.ID),
-			Machine:    route.Machine.Proto(),
+			Node:       route.Node.Proto(),
 			Prefix:     netip.Prefix(route.Prefix).String(),
 			Advertised: route.Advertised,
 			Enabled:    route.Enabled,
diff --git a/integration/cli_test.go b/integration/cli_test.go
index ef0ed70175..61439c3f97 100644
--- a/integration/cli_test.go
+++ b/integration/cli_test.go
@@ -686,7 +686,7 @@ func TestNodeTagCommand(t *testing.T) {
 		"nodekey:9b2ffa7e08cc421a3d2cca9012280f6a236fd0de0b4ce005b30a98ad930306fe",
 		"nodekey:6abd00bb5fdda622db51387088c68e97e71ce58e7056aa54f592b6a8219d524c",
 	}
-	machines := make([]*v1.Machine, len(machineKeys))
+	nodes := make([]*v1.Node, len(machineKeys))
 	assert.Nil(t, err)
 
 	for index, machineKey := range machineKeys {
@@ -696,7 +696,7 @@ func TestNodeTagCommand(t *testing.T) {
 				"debug",
 				"create-node",
 				"--name",
-				fmt.Sprintf("machine-%d", index+1),
+				fmt.Sprintf("node-%d", index+1),
 				"--user",
 				"user1",
 				"--key",
@@ -707,7 +707,7 @@ func TestNodeTagCommand(t *testing.T) {
 		)
 		assert.Nil(t, err)
 
-		var machine v1.Machine
+		var node v1.Node
 		err = executeAndUnmarshal(
 			headscale,
 			[]string{
@@ -721,15 +721,15 @@ func TestNodeTagCommand(t *testing.T) {
 				"--output",
 				"json",
 			},
-			&machine,
+			&node,
 		)
 		assert.Nil(t, err)
 
-		machines[index] = &machine
+		nodes[index] = &node
 	}
-	assert.Len(t, machines, len(machineKeys))
+	assert.Len(t, nodes, len(machineKeys))
 
-	var machine v1.Machine
+	var node v1.Node
 	err = executeAndUnmarshal(
 		headscale,
 		[]string{
@@ -740,11 +740,11 @@ func TestNodeTagCommand(t *testing.T) {
 			"-t", "tag:test",
 			"--output", "json",
 		},
-		&machine,
+		&node,
 	)
 	assert.Nil(t, err)
 
-	assert.Equal(t, []string{"tag:test"}, machine.ForcedTags)
+	assert.Equal(t, []string{"tag:test"}, node.ForcedTags)
 
 	// try to set a wrong tag and retrieve the error
 	type errOutput struct {
@@ -767,7 +767,7 @@ func TestNodeTagCommand(t *testing.T) {
 	assert.Contains(t, errorOutput.Error, "tag must start with the string 'tag:'")
 
 	// Test list all nodes after added seconds
-	resultMachines := make([]*v1.Machine, len(machineKeys))
+	resultMachines := make([]*v1.Node, len(machineKeys))
 	err = executeAndUnmarshal(
 		headscale,
 		[]string{
@@ -780,9 +780,9 @@ func TestNodeTagCommand(t *testing.T) {
 	)
 	assert.Nil(t, err)
 	found := false
-	for _, machine := range resultMachines {
-		if machine.ForcedTags != nil {
-			for _, tag := range machine.ForcedTags {
+	for _, node := range resultMachines {
+		if node.ForcedTags != nil {
+			for _, tag := range node.ForcedTags {
 				if tag == "tag:test" {
 					found = true
 				}
@@ -793,7 +793,7 @@ func TestNodeTagCommand(t *testing.T) {
 		t,
 		true,
 		found,
-		"should find a machine with the tag 'tag:test' in the list of machines",
+		"should find a node with the tag 'tag:test' in the list of nodes",
 	)
 }
 
@@ -806,8 +806,8 @@ func TestNodeCommand(t *testing.T) {
 	defer scenario.Shutdown()
 
 	spec := map[string]int{
-		"machine-user": 0,
-		"other-user":   0,
+		"node-user":  0,
+		"other-user": 0,
 	}
 
 	err = scenario.CreateHeadscaleEnv(spec, []tsic.Option{}, hsic.WithTestName("clins"))
@@ -816,7 +816,7 @@ func TestNodeCommand(t *testing.T) {
 	headscale, err := scenario.Headscale()
 	assertNoErr(t, err)
 
-	// Randomly generated machine keys
+	// Randomly generated node keys
 	machineKeys := []string{
 		"nodekey:9b2ffa7e08cc421a3d2cca9012280f6a236fd0de0b4ce005b30a98ad930306fe",
 		"nodekey:6abd00bb5fdda622db51387088c68e97e71ce58e7056aa54f592b6a8219d524c",
@@ -824,7 +824,7 @@ func TestNodeCommand(t *testing.T) {
 		"nodekey:8bc13285cee598acf76b1824a6f4490f7f2e3751b201e28aeb3b07fe81d5b4a1",
 		"nodekey:cf7b0fd05da556fdc3bab365787b506fd82d64a70745db70e00e86c1b1c03084",
 	}
-	machines := make([]*v1.Machine, len(machineKeys))
+	nodes := make([]*v1.Node, len(machineKeys))
 	assert.Nil(t, err)
 
 	for index, machineKey := range machineKeys {
@@ -834,9 +834,9 @@ func TestNodeCommand(t *testing.T) {
 				"debug",
 				"create-node",
 				"--name",
-				fmt.Sprintf("machine-%d", index+1),
+				fmt.Sprintf("node-%d", index+1),
 				"--user",
-				"machine-user",
+				"node-user",
 				"--key",
 				machineKey,
 				"--output",
@@ -845,31 +845,31 @@ func TestNodeCommand(t *testing.T) {
 		)
 		assert.Nil(t, err)
 
-		var machine v1.Machine
+		var node v1.Node
 		err = executeAndUnmarshal(
 			headscale,
 			[]string{
 				"headscale",
 				"nodes",
 				"--user",
-				"machine-user",
+				"node-user",
 				"register",
 				"--key",
 				machineKey,
 				"--output",
 				"json",
 			},
-			&machine,
+			&node,
 		)
 		assert.Nil(t, err)
 
-		machines[index] = &machine
+		nodes[index] = &node
 	}
 
-	assert.Len(t, machines, len(machineKeys))
+	assert.Len(t, nodes, len(machineKeys))
 
 	// Test list all nodes after added seconds
-	var listAll []v1.Machine
+	var listAll []v1.Node
 	err = executeAndUnmarshal(
 		headscale,
 		[]string{
@@ -891,17 +891,17 @@ func TestNodeCommand(t *testing.T) {
 	assert.Equal(t, uint64(4), listAll[3].Id)
 	assert.Equal(t, uint64(5), listAll[4].Id)
 
-	assert.Equal(t, "machine-1", listAll[0].Name)
-	assert.Equal(t, "machine-2", listAll[1].Name)
-	assert.Equal(t, "machine-3", listAll[2].Name)
-	assert.Equal(t, "machine-4", listAll[3].Name)
-	assert.Equal(t, "machine-5", listAll[4].Name)
+	assert.Equal(t, "node-1", listAll[0].Name)
+	assert.Equal(t, "node-2", listAll[1].Name)
+	assert.Equal(t, "node-3", listAll[2].Name)
+	assert.Equal(t, "node-4", listAll[3].Name)
+	assert.Equal(t, "node-5", listAll[4].Name)
 
 	otherUserMachineKeys := []string{
 		"nodekey:b5b444774186d4217adcec407563a1223929465ee2c68a4da13af0d0185b4f8e",
 		"nodekey:dc721977ac7415aafa87f7d4574cbe07c6b171834a6d37375782bdc1fb6b3584",
 	}
-	otherUserMachines := make([]*v1.Machine, len(otherUserMachineKeys))
+	otherUserMachines := make([]*v1.Node, len(otherUserMachineKeys))
 	assert.Nil(t, err)
 
 	for index, machineKey := range otherUserMachineKeys {
@@ -911,7 +911,7 @@ func TestNodeCommand(t *testing.T) {
 				"debug",
 				"create-node",
 				"--name",
-				fmt.Sprintf("otherUser-machine-%d", index+1),
+				fmt.Sprintf("otherUser-node-%d", index+1),
 				"--user",
 				"other-user",
 				"--key",
@@ -922,7 +922,7 @@ func TestNodeCommand(t *testing.T) {
 		)
 		assert.Nil(t, err)
 
-		var machine v1.Machine
+		var node v1.Node
 		err = executeAndUnmarshal(
 			headscale,
 			[]string{
@@ -936,17 +936,17 @@ func TestNodeCommand(t *testing.T) {
 				"--output",
 				"json",
 			},
-			&machine,
+			&node,
 		)
 		assert.Nil(t, err)
 
-		otherUserMachines[index] = &machine
+		otherUserMachines[index] = &node
 	}
 
 	assert.Len(t, otherUserMachines, len(otherUserMachineKeys))
 
 	// Test list all nodes after added otherUser
-	var listAllWithotherUser []v1.Machine
+	var listAllWithotherUser []v1.Node
 	err = executeAndUnmarshal(
 		headscale,
 		[]string{
@@ -960,17 +960,17 @@ func TestNodeCommand(t *testing.T) {
 	)
 	assert.Nil(t, err)
 
-	// All nodes, machines + otherUser
+	// All nodes, nodes + otherUser
 	assert.Len(t, listAllWithotherUser, 7)
 
 	assert.Equal(t, uint64(6), listAllWithotherUser[5].Id)
 	assert.Equal(t, uint64(7), listAllWithotherUser[6].Id)
 
-	assert.Equal(t, "otherUser-machine-1", listAllWithotherUser[5].Name)
-	assert.Equal(t, "otherUser-machine-2", listAllWithotherUser[6].Name)
+	assert.Equal(t, "otherUser-node-1", listAllWithotherUser[5].Name)
+	assert.Equal(t, "otherUser-node-2", listAllWithotherUser[6].Name)
 
 	// Test list all nodes after added otherUser
-	var listOnlyotherUserMachineUser []v1.Machine
+	var listOnlyotherUserMachineUser []v1.Node
 	err = executeAndUnmarshal(
 		headscale,
 		[]string{
@@ -993,16 +993,16 @@ func TestNodeCommand(t *testing.T) {
 
 	assert.Equal(
 		t,
-		"otherUser-machine-1",
+		"otherUser-node-1",
 		listOnlyotherUserMachineUser[0].Name,
 	)
 	assert.Equal(
 		t,
-		"otherUser-machine-2",
+		"otherUser-node-2",
 		listOnlyotherUserMachineUser[1].Name,
 	)
 
-	// Delete a machines
+	// Delete a nodes
 	_, err = headscale.Execute(
 		[]string{
 			"headscale",
@@ -1018,8 +1018,8 @@ func TestNodeCommand(t *testing.T) {
 	)
 	assert.Nil(t, err)
 
-	// Test: list main user after machine is deleted
-	var listOnlyMachineUserAfterDelete []v1.Machine
+	// Test: list main user after node is deleted
+	var listOnlyMachineUserAfterDelete []v1.Node
 	err = executeAndUnmarshal(
 		headscale,
 		[]string{
@@ -1027,7 +1027,7 @@ func TestNodeCommand(t *testing.T) {
 			"nodes",
 			"list",
 			"--user",
-			"machine-user",
+			"node-user",
 			"--output",
 			"json",
 		},
@@ -1047,7 +1047,7 @@ func TestNodeExpireCommand(t *testing.T) {
 	defer scenario.Shutdown()
 
 	spec := map[string]int{
-		"machine-expire-user": 0,
+		"node-expire-user": 0,
 	}
 
 	err = scenario.CreateHeadscaleEnv(spec, []tsic.Option{}, hsic.WithTestName("clins"))
@@ -1056,7 +1056,7 @@ func TestNodeExpireCommand(t *testing.T) {
 	headscale, err := scenario.Headscale()
 	assertNoErr(t, err)
 
-	// Randomly generated machine keys
+	// Randomly generated node keys
 	machineKeys := []string{
 		"nodekey:9b2ffa7e08cc421a3d2cca9012280f6a236fd0de0b4ce005b30a98ad930306fe",
 		"nodekey:6abd00bb5fdda622db51387088c68e97e71ce58e7056aa54f592b6a8219d524c",
@@ -1064,7 +1064,7 @@ func TestNodeExpireCommand(t *testing.T) {
 		"nodekey:8bc13285cee598acf76b1824a6f4490f7f2e3751b201e28aeb3b07fe81d5b4a1",
 		"nodekey:cf7b0fd05da556fdc3bab365787b506fd82d64a70745db70e00e86c1b1c03084",
 	}
-	machines := make([]*v1.Machine, len(machineKeys))
+	nodes := make([]*v1.Node, len(machineKeys))
 
 	for index, machineKey := range machineKeys {
 		_, err := headscale.Execute(
@@ -1073,9 +1073,9 @@ func TestNodeExpireCommand(t *testing.T) {
 				"debug",
 				"create-node",
 				"--name",
-				fmt.Sprintf("machine-%d", index+1),
+				fmt.Sprintf("node-%d", index+1),
 				"--user",
-				"machine-expire-user",
+				"node-expire-user",
 				"--key",
 				machineKey,
 				"--output",
@@ -1084,30 +1084,30 @@ func TestNodeExpireCommand(t *testing.T) {
 		)
 		assert.Nil(t, err)
 
-		var machine v1.Machine
+		var node v1.Node
 		err = executeAndUnmarshal(
 			headscale,
 			[]string{
 				"headscale",
 				"nodes",
 				"--user",
-				"machine-expire-user",
+				"node-expire-user",
 				"register",
 				"--key",
 				machineKey,
 				"--output",
 				"json",
 			},
-			&machine,
+			&node,
 		)
 		assert.Nil(t, err)
 
-		machines[index] = &machine
+		nodes[index] = &node
 	}
 
-	assert.Len(t, machines, len(machineKeys))
+	assert.Len(t, nodes, len(machineKeys))
 
-	var listAll []v1.Machine
+	var listAll []v1.Node
 	err = executeAndUnmarshal(
 		headscale,
 		[]string{
@@ -1142,7 +1142,7 @@ func TestNodeExpireCommand(t *testing.T) {
 		assert.Nil(t, err)
 	}
 
-	var listAllAfterExpiry []v1.Machine
+	var listAllAfterExpiry []v1.Node
 	err = executeAndUnmarshal(
 		headscale,
 		[]string{
@@ -1174,7 +1174,7 @@ func TestNodeRenameCommand(t *testing.T) {
 	defer scenario.Shutdown()
 
 	spec := map[string]int{
-		"machine-rename-command": 0,
+		"node-rename-command": 0,
 	}
 
 	err = scenario.CreateHeadscaleEnv(spec, []tsic.Option{}, hsic.WithTestName("clins"))
@@ -1183,7 +1183,7 @@ func TestNodeRenameCommand(t *testing.T) {
 	headscale, err := scenario.Headscale()
 	assertNoErr(t, err)
 
-	// Randomly generated machine keys
+	// Randomly generated node keys
 	machineKeys := []string{
 		"nodekey:cf7b0fd05da556fdc3bab365787b506fd82d64a70745db70e00e86c1b1c03084",
 		"nodekey:8bc13285cee598acf76b1824a6f4490f7f2e3751b201e28aeb3b07fe81d5b4a1",
@@ -1191,7 +1191,7 @@ func TestNodeRenameCommand(t *testing.T) {
 		"nodekey:6abd00bb5fdda622db51387088c68e97e71ce58e7056aa54f592b6a8219d524c",
 		"nodekey:9b2ffa7e08cc421a3d2cca9012280f6a236fd0de0b4ce005b30a98ad930306fe",
 	}
-	machines := make([]*v1.Machine, len(machineKeys))
+	nodes := make([]*v1.Node, len(machineKeys))
 	assert.Nil(t, err)
 
 	for index, machineKey := range machineKeys {
@@ -1201,9 +1201,9 @@ func TestNodeRenameCommand(t *testing.T) {
 				"debug",
 				"create-node",
 				"--name",
-				fmt.Sprintf("machine-%d", index+1),
+				fmt.Sprintf("node-%d", index+1),
 				"--user",
-				"machine-rename-command",
+				"node-rename-command",
 				"--key",
 				machineKey,
 				"--output",
@@ -1212,30 +1212,30 @@ func TestNodeRenameCommand(t *testing.T) {
 		)
 		assert.Nil(t, err)
 
-		var machine v1.Machine
+		var node v1.Node
 		err = executeAndUnmarshal(
 			headscale,
 			[]string{
 				"headscale",
 				"nodes",
 				"--user",
-				"machine-rename-command",
+				"node-rename-command",
 				"register",
 				"--key",
 				machineKey,
 				"--output",
 				"json",
 			},
-			&machine,
+			&node,
 		)
 		assert.Nil(t, err)
 
-		machines[index] = &machine
+		nodes[index] = &node
 	}
 
-	assert.Len(t, machines, len(machineKeys))
+	assert.Len(t, nodes, len(machineKeys))
 
-	var listAll []v1.Machine
+	var listAll []v1.Node
 	err = executeAndUnmarshal(
 		headscale,
 		[]string{
@@ -1251,11 +1251,11 @@ func TestNodeRenameCommand(t *testing.T) {
 
 	assert.Len(t, listAll, 5)
 
-	assert.Contains(t, listAll[0].GetGivenName(), "machine-1")
-	assert.Contains(t, listAll[1].GetGivenName(), "machine-2")
-	assert.Contains(t, listAll[2].GetGivenName(), "machine-3")
-	assert.Contains(t, listAll[3].GetGivenName(), "machine-4")
-	assert.Contains(t, listAll[4].GetGivenName(), "machine-5")
+	assert.Contains(t, listAll[0].GetGivenName(), "node-1")
+	assert.Contains(t, listAll[1].GetGivenName(), "node-2")
+	assert.Contains(t, listAll[2].GetGivenName(), "node-3")
+	assert.Contains(t, listAll[3].GetGivenName(), "node-4")
+	assert.Contains(t, listAll[4].GetGivenName(), "node-5")
 
 	for idx := 0; idx < 3; idx++ {
 		_, err := headscale.Execute(
@@ -1265,13 +1265,13 @@ func TestNodeRenameCommand(t *testing.T) {
 				"rename",
 				"--identifier",
 				fmt.Sprintf("%d", listAll[idx].Id),
-				fmt.Sprintf("newmachine-%d", idx+1),
+				fmt.Sprintf("newnode-%d", idx+1),
 			},
 		)
 		assert.Nil(t, err)
 	}
 
-	var listAllAfterRename []v1.Machine
+	var listAllAfterRename []v1.Node
 	err = executeAndUnmarshal(
 		headscale,
 		[]string{
@@ -1287,11 +1287,11 @@ func TestNodeRenameCommand(t *testing.T) {
 
 	assert.Len(t, listAllAfterRename, 5)
 
-	assert.Equal(t, "newmachine-1", listAllAfterRename[0].GetGivenName())
-	assert.Equal(t, "newmachine-2", listAllAfterRename[1].GetGivenName())
-	assert.Equal(t, "newmachine-3", listAllAfterRename[2].GetGivenName())
-	assert.Contains(t, listAllAfterRename[3].GetGivenName(), "machine-4")
-	assert.Contains(t, listAllAfterRename[4].GetGivenName(), "machine-5")
+	assert.Equal(t, "newnode-1", listAllAfterRename[0].GetGivenName())
+	assert.Equal(t, "newnode-2", listAllAfterRename[1].GetGivenName())
+	assert.Equal(t, "newnode-3", listAllAfterRename[2].GetGivenName())
+	assert.Contains(t, listAllAfterRename[3].GetGivenName(), "node-4")
+	assert.Contains(t, listAllAfterRename[4].GetGivenName(), "node-5")
 
 	// Test failure for too long names
 	result, err := headscale.Execute(
@@ -1307,7 +1307,7 @@ func TestNodeRenameCommand(t *testing.T) {
 	assert.Nil(t, err)
 	assert.Contains(t, result, "not be over 63 chars")
 
-	var listAllAfterRenameAttempt []v1.Machine
+	var listAllAfterRenameAttempt []v1.Node
 	err = executeAndUnmarshal(
 		headscale,
 		[]string{
@@ -1323,11 +1323,11 @@ func TestNodeRenameCommand(t *testing.T) {
 
 	assert.Len(t, listAllAfterRenameAttempt, 5)
 
-	assert.Equal(t, "newmachine-1", listAllAfterRenameAttempt[0].GetGivenName())
-	assert.Equal(t, "newmachine-2", listAllAfterRenameAttempt[1].GetGivenName())
-	assert.Equal(t, "newmachine-3", listAllAfterRenameAttempt[2].GetGivenName())
-	assert.Contains(t, listAllAfterRenameAttempt[3].GetGivenName(), "machine-4")
-	assert.Contains(t, listAllAfterRenameAttempt[4].GetGivenName(), "machine-5")
+	assert.Equal(t, "newnode-1", listAllAfterRenameAttempt[0].GetGivenName())
+	assert.Equal(t, "newnode-2", listAllAfterRenameAttempt[1].GetGivenName())
+	assert.Equal(t, "newnode-3", listAllAfterRenameAttempt[2].GetGivenName())
+	assert.Contains(t, listAllAfterRenameAttempt[3].GetGivenName(), "node-4")
+	assert.Contains(t, listAllAfterRenameAttempt[4].GetGivenName(), "node-5")
 }
 
 func TestNodeMoveCommand(t *testing.T) {
@@ -1349,7 +1349,7 @@ func TestNodeMoveCommand(t *testing.T) {
 	headscale, err := scenario.Headscale()
 	assertNoErr(t, err)
 
-	// Randomly generated machine key
+	// Randomly generated node key
 	machineKey := "nodekey:688411b767663479632d44140f08a9fde87383adc7cdeb518f62ce28a17ef0aa"
 
 	_, err = headscale.Execute(
@@ -1358,7 +1358,7 @@ func TestNodeMoveCommand(t *testing.T) {
 			"debug",
 			"create-node",
 			"--name",
-			"nomad-machine",
+			"nomad-node",
 			"--user",
 			"old-user",
 			"--key",
@@ -1369,7 +1369,7 @@ func TestNodeMoveCommand(t *testing.T) {
 	)
 	assert.Nil(t, err)
 
-	var machine v1.Machine
+	var node v1.Node
 	err = executeAndUnmarshal(
 		headscale,
 		[]string{
@@ -1383,15 +1383,15 @@ func TestNodeMoveCommand(t *testing.T) {
 			"--output",
 			"json",
 		},
-		&machine,
+		&node,
 	)
 	assert.Nil(t, err)
 
-	assert.Equal(t, uint64(1), machine.Id)
-	assert.Equal(t, "nomad-machine", machine.Name)
-	assert.Equal(t, machine.User.Name, "old-user")
+	assert.Equal(t, uint64(1), node.Id)
+	assert.Equal(t, "nomad-node", node.Name)
+	assert.Equal(t, node.User.Name, "old-user")
 
-	machineID := fmt.Sprintf("%d", machine.Id)
+	nodeID := fmt.Sprintf("%d", node.Id)
 
 	err = executeAndUnmarshal(
 		headscale,
@@ -1400,19 +1400,19 @@ func TestNodeMoveCommand(t *testing.T) {
 			"nodes",
 			"move",
 			"--identifier",
-			machineID,
+			nodeID,
 			"--user",
 			"new-user",
 			"--output",
 			"json",
 		},
-		&machine,
+		&node,
 	)
 	assert.Nil(t, err)
 
-	assert.Equal(t, machine.User.Name, "new-user")
+	assert.Equal(t, node.User.Name, "new-user")
 
-	var allNodes []v1.Machine
+	var allNodes []v1.Node
 	err = executeAndUnmarshal(
 		headscale,
 		[]string{
@@ -1428,8 +1428,8 @@ func TestNodeMoveCommand(t *testing.T) {
 
 	assert.Len(t, allNodes, 1)
 
-	assert.Equal(t, allNodes[0].Id, machine.Id)
-	assert.Equal(t, allNodes[0].User, machine.User)
+	assert.Equal(t, allNodes[0].Id, node.Id)
+	assert.Equal(t, allNodes[0].User, node.User)
 	assert.Equal(t, allNodes[0].User.Name, "new-user")
 
 	moveToNonExistingNSResult, err := headscale.Execute(
@@ -1438,7 +1438,7 @@ func TestNodeMoveCommand(t *testing.T) {
 			"nodes",
 			"move",
 			"--identifier",
-			machineID,
+			nodeID,
 			"--user",
 			"non-existing-user",
 			"--output",
@@ -1452,7 +1452,7 @@ func TestNodeMoveCommand(t *testing.T) {
 		moveToNonExistingNSResult,
 		"user not found",
 	)
-	assert.Equal(t, machine.User.Name, "new-user")
+	assert.Equal(t, node.User.Name, "new-user")
 
 	err = executeAndUnmarshal(
 		headscale,
@@ -1461,17 +1461,17 @@ func TestNodeMoveCommand(t *testing.T) {
 			"nodes",
 			"move",
 			"--identifier",
-			machineID,
+			nodeID,
 			"--user",
 			"old-user",
 			"--output",
 			"json",
 		},
-		&machine,
+		&node,
 	)
 	assert.Nil(t, err)
 
-	assert.Equal(t, machine.User.Name, "old-user")
+	assert.Equal(t, node.User.Name, "old-user")
 
 	err = executeAndUnmarshal(
 		headscale,
@@ -1480,15 +1480,15 @@ func TestNodeMoveCommand(t *testing.T) {
 			"nodes",
 			"move",
 			"--identifier",
-			machineID,
+			nodeID,
 			"--user",
 			"old-user",
 			"--output",
 			"json",
 		},
-		&machine,
+		&node,
 	)
 	assert.Nil(t, err)
 
-	assert.Equal(t, machine.User.Name, "old-user")
+	assert.Equal(t, node.User.Name, "old-user")
 }
diff --git a/integration/control.go b/integration/control.go
index b41100705a..f5557495a0 100644
--- a/integration/control.go
+++ b/integration/control.go
@@ -16,7 +16,7 @@ type ControlServer interface {
 	WaitForRunning() error
 	CreateUser(user string) error
 	CreateAuthKey(user string, reusable bool, ephemeral bool) (*v1.PreAuthKey, error)
-	ListMachinesInUser(user string) ([]*v1.Machine, error)
+	ListNodesInUser(user string) ([]*v1.Node, error)
 	GetCert() []byte
 	GetHostname() string
 	GetIP() string
diff --git a/integration/general_test.go b/integration/general_test.go
index 4de121c73e..ca2394aaf3 100644
--- a/integration/general_test.go
+++ b/integration/general_test.go
@@ -223,18 +223,18 @@ func TestEphemeral(t *testing.T) {
 	t.Logf("all clients logged out")
 
 	for userName := range spec {
-		machines, err := headscale.ListMachinesInUser(userName)
+		nodes, err := headscale.ListNodesInUser(userName)
 		if err != nil {
 			log.Error().
 				Err(err).
 				Str("user", userName).
-				Msg("Error listing machines in user")
+				Msg("Error listing nodes in user")
 
 			return
 		}
 
-		if len(machines) != 0 {
-			t.Fatalf("expected no machines, got %d in user %s", len(machines), userName)
+		if len(nodes) != 0 {
+			t.Fatalf("expected no nodes, got %d in user %s", len(nodes), userName)
 		}
 	}
 }
@@ -513,8 +513,8 @@ func TestExpireNode(t *testing.T) {
 	})
 	assertNoErr(t, err)
 
-	var machine v1.Machine
-	err = json.Unmarshal([]byte(result), &machine)
+	var node v1.Node
+	err = json.Unmarshal([]byte(result), &node)
 	assertNoErr(t, err)
 
 	time.Sleep(30 * time.Second)
@@ -530,10 +530,10 @@ func TestExpireNode(t *testing.T) {
 
 			peerPublicKey := strings.TrimPrefix(peerStatus.PublicKey.String(), "nodekey:")
 
-			assert.NotEqual(t, machine.NodeKey, peerPublicKey)
+			assert.NotEqual(t, node.NodeKey, peerPublicKey)
 		}
 
-		if client.Hostname() != machine.Name {
+		if client.Hostname() != node.Name {
 			// Assert that we have the original count - self - expired node
 			assert.Len(t, status.Peers(), len(MustTestVersions)-2)
 		}
diff --git a/integration/hsic/hsic.go b/integration/hsic/hsic.go
index 7d1bbceb3a..64aaebb7ec 100644
--- a/integration/hsic/hsic.go
+++ b/integration/hsic/hsic.go
@@ -547,11 +547,11 @@ func (t *HeadscaleInContainer) CreateAuthKey(
 	return &preAuthKey, nil
 }
 
-// ListMachinesInUser list the TailscaleClients (Machine, Headscale internal representation)
+// ListNodesInUser list the TailscaleClients (Node, Headscale internal representation)
 // associated with a user.
-func (t *HeadscaleInContainer) ListMachinesInUser(
+func (t *HeadscaleInContainer) ListNodesInUser(
 	user string,
-) ([]*v1.Machine, error) {
+) ([]*v1.Node, error) {
 	command := []string{"headscale", "--user", user, "nodes", "list", "--output", "json"}
 
 	result, _, err := dockertestutil.ExecuteCommand(
@@ -563,7 +563,7 @@ func (t *HeadscaleInContainer) ListMachinesInUser(
 		return nil, fmt.Errorf("failed to execute list node command: %w", err)
 	}
 
-	var nodes []*v1.Machine
+	var nodes []*v1.Node
 	err = json.Unmarshal([]byte(result), &nodes)
 	if err != nil {
 		return nil, fmt.Errorf("failed to unmarshal nodes: %w", err)
diff --git a/proto/headscale/v1/headscale.proto b/proto/headscale/v1/headscale.proto
index e142f22b14..e113c192aa 100644
--- a/proto/headscale/v1/headscale.proto
+++ b/proto/headscale/v1/headscale.proto
@@ -6,7 +6,7 @@ import "google/api/annotations.proto";
 
 import "headscale/v1/user.proto";
 import "headscale/v1/preauthkey.proto";
-import "headscale/v1/machine.proto";
+import "headscale/v1/node.proto";
 import "headscale/v1/routes.proto";
 import "headscale/v1/apikey.proto";
 // import "headscale/v1/device.proto";
@@ -67,63 +67,63 @@ service HeadscaleService {
     }
     // --- PreAuthKeys end ---
 
-    // --- Machine start ---
-    rpc DebugCreateMachine(DebugCreateMachineRequest) returns(DebugCreateMachineResponse) {
+    // --- Node start ---
+    rpc DebugCreateNode(DebugCreateNodeRequest) returns(DebugCreateNodeResponse) {
         option(google.api.http) = {
-            post : "/api/v1/debug/machine"
+            post : "/api/v1/debug/node"
             body : "*"
         };
     }
 
-    rpc GetMachine(GetMachineRequest) returns(GetMachineResponse) {
+    rpc GetNode(GetNodeRequest) returns(GetNodeResponse) {
         option(google.api.http) = {
-            get : "/api/v1/machine/{machine_id}"
+            get : "/api/v1/node/{node_id}"
         };
     }
 
     rpc SetTags(SetTagsRequest) returns(SetTagsResponse) {
         option(google.api.http) = {
-            post : "/api/v1/machine/{machine_id}/tags"
+            post : "/api/v1/node/{node_id}/tags"
             body : "*"
         };
     }
 
-    rpc RegisterMachine(RegisterMachineRequest) returns(RegisterMachineResponse) {
+    rpc RegisterNode(RegisterNodeRequest) returns(RegisterNodeResponse) {
         option(google.api.http) = {
-            post : "/api/v1/machine/register"
+            post : "/api/v1/node/register"
         };
     }
 
-    rpc DeleteMachine(DeleteMachineRequest) returns(DeleteMachineResponse) {
+    rpc DeleteNode(DeleteNodeRequest) returns(DeleteNodeResponse) {
         option(google.api.http) = {
-            delete : "/api/v1/machine/{machine_id}"
+            delete : "/api/v1/node/{node_id}"
         };
     }
 
-    rpc ExpireMachine(ExpireMachineRequest) returns(ExpireMachineResponse) {
+    rpc ExpireNode(ExpireNodeRequest) returns(ExpireNodeResponse) {
         option(google.api.http) = {
-            post : "/api/v1/machine/{machine_id}/expire"
+            post : "/api/v1/node/{node_id}/expire"
         };
     }
 
-    rpc RenameMachine(RenameMachineRequest) returns(RenameMachineResponse) {
+    rpc RenameNode(RenameNodeRequest) returns(RenameNodeResponse) {
         option(google.api.http) = {
-            post : "/api/v1/machine/{machine_id}/rename/{new_name}"
+            post : "/api/v1/node/{node_id}/rename/{new_name}"
         };
     }
 
-    rpc ListMachines(ListMachinesRequest) returns(ListMachinesResponse) {
+    rpc ListNodes(ListNodesRequest) returns(ListNodesResponse) {
         option(google.api.http) = {
-            get : "/api/v1/machine"
+            get : "/api/v1/node"
         };
     }
 
-    rpc MoveMachine(MoveMachineRequest) returns(MoveMachineResponse) {
+    rpc MoveNode(MoveNodeRequest) returns(MoveNodeResponse) {
         option(google.api.http) = {
-            post : "/api/v1/machine/{machine_id}/user"
+            post : "/api/v1/node/{node_id}/user"
         };
     }
-    // --- Machine end ---
+    // --- Node end ---
 
     // --- Route start ---
     rpc GetRoutes(GetRoutesRequest) returns(GetRoutesResponse) {
@@ -144,9 +144,9 @@ service HeadscaleService {
         };
     }
 
-    rpc GetMachineRoutes(GetMachineRoutesRequest) returns(GetMachineRoutesResponse) {
+    rpc GetNodeRoutes(GetNodeRoutesRequest) returns(GetNodeRoutesResponse) {
         option(google.api.http) = {
-            get : "/api/v1/machine/{machine_id}/routes"
+            get : "/api/v1/node/{node_id}/routes"
         };
     }
 
diff --git a/proto/headscale/v1/machine.proto b/proto/headscale/v1/node.proto
similarity index 66%
rename from proto/headscale/v1/machine.proto
rename to proto/headscale/v1/node.proto
index e3e6e53051..476aa59a44 100644
--- a/proto/headscale/v1/machine.proto
+++ b/proto/headscale/v1/node.proto
@@ -13,7 +13,7 @@ enum RegisterMethod {
     REGISTER_METHOD_OIDC        = 3;
 }
 
-message Machine {
+message Node {
     uint64          id           = 1;
     string          machine_key  = 2;
     string          node_key     = 3;
@@ -47,80 +47,80 @@ message Machine {
     bool            online       = 22;
 }
 
-message RegisterMachineRequest {
+message RegisterNodeRequest {
     string user = 1;
     string key       = 2;
 }
 
-message RegisterMachineResponse {
-    Machine machine = 1;
+message RegisterNodeResponse {
+    Node node = 1;
 }
 
-message GetMachineRequest {
-    uint64 machine_id = 1;
+message GetNodeRequest {
+    uint64 node_id = 1;
 }
 
-message GetMachineResponse {
-    Machine machine = 1;
+message GetNodeResponse {
+    Node node = 1;
 }
 
 message SetTagsRequest {
-    uint64          machine_id = 1;
+    uint64          node_id = 1;
     repeated string tags       = 2;
 }
 
 message SetTagsResponse {
-    Machine machine = 1;
+    Node node = 1;
 }
 
-message DeleteMachineRequest {
-    uint64 machine_id = 1;
+message DeleteNodeRequest {
+    uint64 node_id = 1;
 }
 
-message DeleteMachineResponse {
+message DeleteNodeResponse {
 }
 
-message ExpireMachineRequest {
-    uint64 machine_id = 1;
+message ExpireNodeRequest {
+    uint64 node_id = 1;
 }
 
-message ExpireMachineResponse {
-    Machine machine = 1;
+message ExpireNodeResponse {
+    Node node = 1;
 }
 
-message RenameMachineRequest {
-    uint64 machine_id = 1;
+message RenameNodeRequest {
+    uint64 node_id = 1;
     string new_name   = 2;
 }
 
-message RenameMachineResponse {
-    Machine machine = 1;
+message RenameNodeResponse {
+    Node node = 1;
 }
 
-message ListMachinesRequest {
+message ListNodesRequest {
     string user = 1;
 }
 
-message ListMachinesResponse {
-    repeated Machine machines = 1;
+message ListNodesResponse {
+    repeated Node nodes = 1;
 }
 
-message MoveMachineRequest {
-    uint64 machine_id = 1;
+message MoveNodeRequest {
+    uint64 node_id = 1;
     string user  = 2;
 }
 
-message MoveMachineResponse {
-    Machine machine = 1;
+message MoveNodeResponse {
+    Node node = 1;
 }
 
-message DebugCreateMachineRequest {
+message DebugCreateNodeRequest {
     string user       = 1;
     string          key    = 2;
     string          name   = 3;
     repeated string routes = 4;
 }
 
-message DebugCreateMachineResponse {
-    Machine machine = 1;
+message DebugCreateNodeResponse {
+    Node node = 1;
 }
diff --git a/proto/headscale/v1/routes.proto b/proto/headscale/v1/routes.proto
index 7bf2653a54..ea90025960 100644
--- a/proto/headscale/v1/routes.proto
+++ b/proto/headscale/v1/routes.proto
@@ -3,11 +3,11 @@ package headscale.v1;
 option  go_package = "github.com/juanfont/headscale/gen/go/v1";
 
 import "google/protobuf/timestamp.proto";
-import "headscale/v1/machine.proto";
+import "headscale/v1/node.proto";
 
 message Route {
     uint64  id          = 1;
-    Machine machine     = 2;
+    Node    node     = 2;
     string  prefix      = 3;
     bool    advertised   = 4;
     bool    enabled     = 5;
@@ -39,11 +39,11 @@ message DisableRouteRequest {
 message DisableRouteResponse {
 }
 
-message GetMachineRoutesRequest {
-    uint64 machine_id = 1;
+message GetNodeRoutesRequest {
+    uint64 node_id = 1;
 }
 
-message GetMachineRoutesResponse {
+message GetNodeRoutesResponse {
     repeated Route routes = 1;
 }