snapshot of https://github.com/cortezaproject/corteza.git (2024.9.x, 2026-09-18; blobs > 131072B omitted)

server/federation/rest/handlers/manageStructure.go

@@ -0,0 +1,190 @@
+package handlers
+
+// This file is auto-generated.
+//
+// Changes to this file may cause incorrect behavior and will be lost if
+// the code is regenerated.
+//
+// Definitions file that controls how this file is generated:
+//
+
+import (
+	"context"
+	"github.com/cortezaproject/corteza/server/federation/rest/request"
+	"github.com/cortezaproject/corteza/server/pkg/api"
+	"github.com/go-chi/chi/v5"
+	"net/http"
+)
+
+type (
+	// Internal API interface
+	ManageStructureAPI interface {
+		ReadExposed(context.Context, *request.ManageStructureReadExposed) (interface{}, error)
+		CreateExposed(context.Context, *request.ManageStructureCreateExposed) (interface{}, error)
+		UpdateExposed(context.Context, *request.ManageStructureUpdateExposed) (interface{}, error)
+		RemoveExposed(context.Context, *request.ManageStructureRemoveExposed) (interface{}, error)
+		ReadShared(context.Context, *request.ManageStructureReadShared) (interface{}, error)
+		CreateMappings(context.Context, *request.ManageStructureCreateMappings) (interface{}, error)
+		ReadMappings(context.Context, *request.ManageStructureReadMappings) (interface{}, error)
+		ListAll(context.Context, *request.ManageStructureListAll) (interface{}, error)
+	}
+
+	// HTTP API interface
+	ManageStructure struct {
+		ReadExposed    func(http.ResponseWriter, *http.Request)
+		CreateExposed  func(http.ResponseWriter, *http.Request)
+		UpdateExposed  func(http.ResponseWriter, *http.Request)
+		RemoveExposed  func(http.ResponseWriter, *http.Request)
+		ReadShared     func(http.ResponseWriter, *http.Request)
+		CreateMappings func(http.ResponseWriter, *http.Request)
+		ReadMappings   func(http.ResponseWriter, *http.Request)
+		ListAll        func(http.ResponseWriter, *http.Request)
+	}
+)
+
+func NewManageStructure(h ManageStructureAPI) *ManageStructure {
+	return &ManageStructure{
+		ReadExposed: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewManageStructureReadExposed()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.ReadExposed(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		CreateExposed: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewManageStructureCreateExposed()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.CreateExposed(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		UpdateExposed: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewManageStructureUpdateExposed()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.UpdateExposed(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		RemoveExposed: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewManageStructureRemoveExposed()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.RemoveExposed(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		ReadShared: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewManageStructureReadShared()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.ReadShared(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		CreateMappings: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewManageStructureCreateMappings()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.CreateMappings(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		ReadMappings: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewManageStructureReadMappings()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.ReadMappings(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		ListAll: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewManageStructureListAll()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.ListAll(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+	}
+}
+
+func (h ManageStructure) MountRoutes(r chi.Router, middlewares ...func(http.Handler) http.Handler) {
+	r.Group(func(r chi.Router) {
+		r.Use(middlewares...)
+		r.Get("/nodes/{nodeID}/modules/{moduleID}/exposed", h.ReadExposed)
+		r.Put("/nodes/{nodeID}/modules/", h.CreateExposed)
+		r.Post("/nodes/{nodeID}/modules/{moduleID}/exposed", h.UpdateExposed)
+		r.Delete("/nodes/{nodeID}/modules/{moduleID}/exposed", h.RemoveExposed)
+		r.Get("/nodes/{nodeID}/modules/{moduleID}/shared", h.ReadShared)
+		r.Put("/nodes/{nodeID}/modules/{moduleID}/mapped", h.CreateMappings)
+		r.Get("/nodes/{nodeID}/modules/{moduleID}/mapped", h.ReadMappings)
+		r.Get("/nodes/{nodeID}/modules/", h.ListAll)
+	})
+}

server/federation/rest/handlers/node.go

@@ -0,0 +1,228 @@
+package handlers
+
+// This file is auto-generated.
+//
+// Changes to this file may cause incorrect behavior and will be lost if
+// the code is regenerated.
+//
+// Definitions file that controls how this file is generated:
+//
+
+import (
+	"context"
+	"github.com/cortezaproject/corteza/server/federation/rest/request"
+	"github.com/cortezaproject/corteza/server/pkg/api"
+	"github.com/go-chi/chi/v5"
+	"net/http"
+)
+
+type (
+	// Internal API interface
+	NodeAPI interface {
+		Search(context.Context, *request.NodeSearch) (interface{}, error)
+		Create(context.Context, *request.NodeCreate) (interface{}, error)
+		Read(context.Context, *request.NodeRead) (interface{}, error)
+		GenerateURI(context.Context, *request.NodeGenerateURI) (interface{}, error)
+		Update(context.Context, *request.NodeUpdate) (interface{}, error)
+		Delete(context.Context, *request.NodeDelete) (interface{}, error)
+		Undelete(context.Context, *request.NodeUndelete) (interface{}, error)
+		Pair(context.Context, *request.NodePair) (interface{}, error)
+		HandshakeConfirm(context.Context, *request.NodeHandshakeConfirm) (interface{}, error)
+		HandshakeComplete(context.Context, *request.NodeHandshakeComplete) (interface{}, error)
+	}
+
+	// HTTP API interface
+	Node struct {
+		Search            func(http.ResponseWriter, *http.Request)
+		Create            func(http.ResponseWriter, *http.Request)
+		Read              func(http.ResponseWriter, *http.Request)
+		GenerateURI       func(http.ResponseWriter, *http.Request)
+		Update            func(http.ResponseWriter, *http.Request)
+		Delete            func(http.ResponseWriter, *http.Request)
+		Undelete          func(http.ResponseWriter, *http.Request)
+		Pair              func(http.ResponseWriter, *http.Request)
+		HandshakeConfirm  func(http.ResponseWriter, *http.Request)
+		HandshakeComplete func(http.ResponseWriter, *http.Request)
+	}
+)
+
+func NewNode(h NodeAPI) *Node {
+	return &Node{
+		Search: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewNodeSearch()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Search(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Create: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewNodeCreate()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Create(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Read: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewNodeRead()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Read(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		GenerateURI: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewNodeGenerateURI()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.GenerateURI(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Update: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewNodeUpdate()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Update(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Delete: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewNodeDelete()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Delete(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Undelete: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewNodeUndelete()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Undelete(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Pair: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewNodePair()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Pair(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		HandshakeConfirm: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewNodeHandshakeConfirm()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.HandshakeConfirm(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		HandshakeComplete: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewNodeHandshakeComplete()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.HandshakeComplete(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+	}
+}
+
+func (h Node) MountRoutes(r chi.Router, middlewares ...func(http.Handler) http.Handler) {
+	r.Group(func(r chi.Router) {
+		r.Use(middlewares...)
+		r.Get("/nodes/", h.Search)
+		r.Post("/nodes/", h.Create)
+		r.Get("/nodes/{nodeID}", h.Read)
+		r.Post("/nodes/{nodeID}/uri", h.GenerateURI)
+		r.Post("/nodes/{nodeID}", h.Update)
+		r.Delete("/nodes/{nodeID}", h.Delete)
+		r.Post("/nodes/{nodeID}/undelete", h.Undelete)
+		r.Post("/nodes/{nodeID}/pair", h.Pair)
+		r.Post("/nodes/{nodeID}/handshake-confirm", h.HandshakeConfirm)
+		r.Post("/nodes/{nodeID}/handshake-complete", h.HandshakeComplete)
+	})
+}

server/federation/rest/handlers/nodeHandshake.go

@@ -0,0 +1,57 @@
+package handlers
+
+// This file is auto-generated.
+//
+// Changes to this file may cause incorrect behavior and will be lost if
+// the code is regenerated.
+//
+// Definitions file that controls how this file is generated:
+//
+
+import (
+	"context"
+	"github.com/cortezaproject/corteza/server/federation/rest/request"
+	"github.com/cortezaproject/corteza/server/pkg/api"
+	"github.com/go-chi/chi/v5"
+	"net/http"
+)
+
+type (
+	// Internal API interface
+	NodeHandshakeAPI interface {
+		Initialize(context.Context, *request.NodeHandshakeInitialize) (interface{}, error)
+	}
+
+	// HTTP API interface
+	NodeHandshake struct {
+		Initialize func(http.ResponseWriter, *http.Request)
+	}
+)
+
+func NewNodeHandshake(h NodeHandshakeAPI) *NodeHandshake {
+	return &NodeHandshake{
+		Initialize: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewNodeHandshakeInitialize()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Initialize(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+	}
+}
+
+func (h NodeHandshake) MountRoutes(r chi.Router, middlewares ...func(http.Handler) http.Handler) {
+	r.Group(func(r chi.Router) {
+		r.Use(middlewares...)
+		r.Post("/nodes/{nodeID}/handshake", h.Initialize)
+	})
+}

server/federation/rest/handlers/permissions.go

@@ -0,0 +1,152 @@
+package handlers
+
+// This file is auto-generated.
+//
+// Changes to this file may cause incorrect behavior and will be lost if
+// the code is regenerated.
+//
+// Definitions file that controls how this file is generated:
+//
+
+import (
+	"context"
+	"github.com/cortezaproject/corteza/server/federation/rest/request"
+	"github.com/cortezaproject/corteza/server/pkg/api"
+	"github.com/go-chi/chi/v5"
+	"net/http"
+)
+
+type (
+	// Internal API interface
+	PermissionsAPI interface {
+		List(context.Context, *request.PermissionsList) (interface{}, error)
+		Effective(context.Context, *request.PermissionsEffective) (interface{}, error)
+		Trace(context.Context, *request.PermissionsTrace) (interface{}, error)
+		Read(context.Context, *request.PermissionsRead) (interface{}, error)
+		Delete(context.Context, *request.PermissionsDelete) (interface{}, error)
+		Update(context.Context, *request.PermissionsUpdate) (interface{}, error)
+	}
+
+	// HTTP API interface
+	Permissions struct {
+		List      func(http.ResponseWriter, *http.Request)
+		Effective func(http.ResponseWriter, *http.Request)
+		Trace     func(http.ResponseWriter, *http.Request)
+		Read      func(http.ResponseWriter, *http.Request)
+		Delete    func(http.ResponseWriter, *http.Request)
+		Update    func(http.ResponseWriter, *http.Request)
+	}
+)
+
+func NewPermissions(h PermissionsAPI) *Permissions {
+	return &Permissions{
+		List: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewPermissionsList()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.List(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Effective: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewPermissionsEffective()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Effective(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Trace: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewPermissionsTrace()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Trace(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Read: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewPermissionsRead()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Read(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Delete: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewPermissionsDelete()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Delete(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Update: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewPermissionsUpdate()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Update(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+	}
+}
+
+func (h Permissions) MountRoutes(r chi.Router, middlewares ...func(http.Handler) http.Handler) {
+	r.Group(func(r chi.Router) {
+		r.Use(middlewares...)
+		r.Get("/permissions/", h.List)
+		r.Get("/permissions/effective", h.Effective)
+		r.Get("/permissions/trace", h.Trace)
+		r.Get("/permissions/{roleID}/rules", h.Read)
+		r.Delete("/permissions/{roleID}/rules", h.Delete)
+		r.Patch("/permissions/{roleID}/rules", h.Update)
+	})
+}

server/federation/rest/handlers/syncData.go

@@ -0,0 +1,95 @@
+package handlers
+
+// This file is auto-generated.
+//
+// Changes to this file may cause incorrect behavior and will be lost if
+// the code is regenerated.
+//
+// Definitions file that controls how this file is generated:
+//
+
+import (
+	"context"
+	"github.com/cortezaproject/corteza/server/federation/rest/request"
+	"github.com/cortezaproject/corteza/server/pkg/api"
+	"github.com/go-chi/chi/v5"
+	"net/http"
+)
+
+type (
+	// Internal API interface
+	SyncDataAPI interface {
+		ReadExposedAll(context.Context, *request.SyncDataReadExposedAll) (interface{}, error)
+		ReadExposedInternal(context.Context, *request.SyncDataReadExposedInternal) (interface{}, error)
+		ReadExposedSocial(context.Context, *request.SyncDataReadExposedSocial) (interface{}, error)
+	}
+
+	// HTTP API interface
+	SyncData struct {
+		ReadExposedAll      func(http.ResponseWriter, *http.Request)
+		ReadExposedInternal func(http.ResponseWriter, *http.Request)
+		ReadExposedSocial   func(http.ResponseWriter, *http.Request)
+	}
+)
+
+func NewSyncData(h SyncDataAPI) *SyncData {
+	return &SyncData{
+		ReadExposedAll: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewSyncDataReadExposedAll()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.ReadExposedAll(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		ReadExposedInternal: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewSyncDataReadExposedInternal()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.ReadExposedInternal(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		ReadExposedSocial: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewSyncDataReadExposedSocial()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.ReadExposedSocial(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+	}
+}
+
+func (h SyncData) MountRoutes(r chi.Router, middlewares ...func(http.Handler) http.Handler) {
+	r.Group(func(r chi.Router) {
+		r.Use(middlewares...)
+		r.Get("/nodes/{nodeID}/modules/exposed/records/", h.ReadExposedAll)
+		r.Get("/nodes/{nodeID}/modules/{moduleID}/records/", h.ReadExposedInternal)
+		r.Get("/nodes/{nodeID}/modules/{moduleID}/records/activity-stream/", h.ReadExposedSocial)
+	})
+}

server/federation/rest/handlers/syncStructure.go

@@ -0,0 +1,76 @@
+package handlers
+
+// This file is auto-generated.
+//
+// Changes to this file may cause incorrect behavior and will be lost if
+// the code is regenerated.
+//
+// Definitions file that controls how this file is generated:
+//
+
+import (
+	"context"
+	"github.com/cortezaproject/corteza/server/federation/rest/request"
+	"github.com/cortezaproject/corteza/server/pkg/api"
+	"github.com/go-chi/chi/v5"
+	"net/http"
+)
+
+type (
+	// Internal API interface
+	SyncStructureAPI interface {
+		ReadExposedInternal(context.Context, *request.SyncStructureReadExposedInternal) (interface{}, error)
+		ReadExposedSocial(context.Context, *request.SyncStructureReadExposedSocial) (interface{}, error)
+	}
+
+	// HTTP API interface
+	SyncStructure struct {
+		ReadExposedInternal func(http.ResponseWriter, *http.Request)
+		ReadExposedSocial   func(http.ResponseWriter, *http.Request)
+	}
+)
+
+func NewSyncStructure(h SyncStructureAPI) *SyncStructure {
+	return &SyncStructure{
+		ReadExposedInternal: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewSyncStructureReadExposedInternal()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.ReadExposedInternal(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		ReadExposedSocial: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewSyncStructureReadExposedSocial()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.ReadExposedSocial(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+	}
+}
+
+func (h SyncStructure) MountRoutes(r chi.Router, middlewares ...func(http.Handler) http.Handler) {
+	r.Group(func(r chi.Router) {
+		r.Use(middlewares...)
+		r.Get("/nodes/{nodeID}/modules/exposed/", h.ReadExposedInternal)
+		r.Get("/nodes/{nodeID}/modules/exposed/activity-stream", h.ReadExposedSocial)
+	})
+}

server/federation/rest/manage_structure.go

@@ -0,0 +1,240 @@
+package rest
+
+import (
+	"context"
+
+	"github.com/cortezaproject/corteza/server/federation/rest/request"
+	"github.com/cortezaproject/corteza/server/federation/service"
+	"github.com/cortezaproject/corteza/server/federation/types"
+)
+
+type (
+	ManageStructure struct{}
+
+	exposedModulePayload struct {
+		*types.ExposedModule
+
+		CanManageModule bool `json:"canManageModule"`
+	}
+
+	sharedModulePayload struct {
+		*types.SharedModule
+
+		CanMapModule bool `json:"canMapModule"`
+	}
+
+	moduleMappingPayload struct {
+		*types.ModuleMapping
+	}
+)
+
+func (ManageStructure) New() *ManageStructure {
+	return &ManageStructure{}
+}
+
+func (ctrl ManageStructure) CreateExposed(ctx context.Context, r *request.ManageStructureCreateExposed) (interface{}, error) {
+	var (
+		mod = &types.ExposedModule{
+			NodeID:             r.NodeID,
+			ComposeModuleID:    r.ComposeModuleID,
+			ComposeNamespaceID: r.ComposeNamespaceID,
+			Name:               r.Name,
+			Handle:             r.Handle,
+			Fields:             r.Fields,
+		}
+	)
+
+	em, err := (service.DefaultExposedModule).Create(ctx, mod)
+	return ctrl.makePayload(ctx, em, err)
+}
+
+func (ctrl ManageStructure) ReadExposed(ctx context.Context, r *request.ManageStructureReadExposed) (interface{}, error) {
+	em, err := (service.DefaultExposedModule).FindByID(ctx, r.GetNodeID(), r.GetModuleID())
+	return ctrl.makePayload(ctx, em, err)
+}
+
+func (ctrl ManageStructure) UpdateExposed(ctx context.Context, r *request.ManageStructureUpdateExposed) (interface{}, error) {
+	var (
+		em = &types.ExposedModule{
+			ID:                 r.ModuleID,
+			NodeID:             r.NodeID,
+			ComposeModuleID:    r.ComposeModuleID,
+			ComposeNamespaceID: r.ComposeNamespaceID,
+			Name:               r.Name,
+			Handle:             r.Handle,
+			Fields:             r.Fields,
+		}
+	)
+
+	em, err := (service.DefaultExposedModule).Update(ctx, em)
+	return ctrl.makePayload(ctx, em, err)
+}
+
+func (ctrl ManageStructure) RemoveExposed(ctx context.Context, r *request.ManageStructureRemoveExposed) (interface{}, error) {
+	em, err := (service.DefaultExposedModule).DeleteByID(ctx, r.NodeID, r.ModuleID)
+	return ctrl.makePayload(ctx, em, err)
+}
+
+func (ctrl ManageStructure) ReadShared(ctx context.Context, r *request.ManageStructureReadShared) (interface{}, error) {
+	list, err := (service.DefaultSharedModule).FindByID(ctx, r.GetNodeID(), r.GetModuleID())
+	return ctrl.makePayload(ctx, list, err)
+}
+
+func (ctrl ManageStructure) CreateMappings(ctx context.Context, r *request.ManageStructureCreateMappings) (interface{}, error) {
+	mm := &types.ModuleMapping{
+		NodeID:             r.NodeID,
+		FederationModuleID: r.ModuleID,
+		ComposeModuleID:    r.ComposeModuleID,
+		ComposeNamespaceID: r.ComposeNamespaceID,
+		FieldMapping:       r.Fields,
+	}
+
+	// check if it exists, do an upsert
+	existing, _, err := service.DefaultModuleMapping.Find(ctx, types.ModuleMappingFilter{
+		NodeID:             r.NodeID,
+		ComposeModuleID:    r.ComposeModuleID,
+		ComposeNamespaceID: r.ComposeNamespaceID,
+		FederationModuleID: r.ModuleID,
+	})
+
+	if err != nil {
+		return nil, err
+	}
+
+	if len(existing) > 0 {
+		// do an update
+		return service.DefaultModuleMapping.Update(ctx, mm)
+	}
+
+	return service.DefaultModuleMapping.Create(ctx, mm)
+}
+
+// ReadMappings outputs an object with the module mappings per each federation module
+func (ctrl ManageStructure) ReadMappings(ctx context.Context, r *request.ManageStructureReadMappings) (interface{}, error) {
+	f := types.ModuleMappingFilter{
+		NodeID:             r.NodeID,
+		FederationModuleID: r.ModuleID,
+	}
+
+	if r.ComposeModuleID > 0 {
+		f.ComposeModuleID = r.ComposeModuleID
+	}
+
+	set, _, err := service.DefaultModuleMapping.Find(ctx, f)
+
+	if err != nil {
+		return nil, err
+	}
+
+	if len(set) != 1 {
+		return nil, service.ModuleMappingErrNotFound()
+	}
+
+	return set[0], nil
+}
+
+// ListAll show the list of exposed / shared / mapped modules
+func (ctrl ManageStructure) ListAll(ctx context.Context, r *request.ManageStructureListAll) (interface{}, error) {
+	var (
+		list interface{}
+		err  error
+	)
+
+	switch true {
+	case r.Exposed:
+		list, _, err = (service.DefaultExposedModule).Find(ctx, types.ExposedModuleFilter{
+			NodeID: r.NodeID,
+		})
+		break
+	case r.Shared:
+		list, _, err = (service.DefaultSharedModule).Find(ctx, types.SharedModuleFilter{
+			NodeID: r.NodeID,
+		})
+		break
+	case r.Mapped:
+		list, _, err = (service.DefaultModuleMapping).Find(ctx, types.ModuleMappingFilter{
+			NodeID: r.NodeID,
+		})
+		break
+	default:
+		return nil, service.ExposedModuleErrRequestParametersInvalid()
+	}
+
+	return ctrl.makePayload(ctx, list, err)
+}
+
+func (ctrl ManageStructure) makeSharedModulePayload(ctx context.Context, sm *types.SharedModule, err error) (*sharedModulePayload, error) {
+	if err != nil || sm == nil {
+		return nil, err
+	}
+
+	return &sharedModulePayload{
+		SharedModule: sm,
+
+		CanMapModule: service.DefaultAccessControl.CanMapSharedModule(ctx, sm),
+	}, nil
+}
+
+func (ctrl ManageStructure) makeExposedModulePayload(ctx context.Context, em *types.ExposedModule, err error) (*exposedModulePayload, error) {
+	if err != nil || em == nil {
+		return nil, err
+	}
+
+	return &exposedModulePayload{
+		ExposedModule: em,
+
+		CanManageModule: service.DefaultAccessControl.CanManageExposedModule(ctx, em),
+	}, nil
+}
+
+func (ctrl ManageStructure) makeModuleMappingPayload(ctx context.Context, em *types.ModuleMapping, err error) (*moduleMappingPayload, error) {
+	if err != nil || em == nil {
+		return nil, err
+	}
+
+	return &moduleMappingPayload{
+		ModuleMapping: em,
+	}, nil
+}
+
+func (ctrl ManageStructure) makePayload(ctx context.Context, payload interface{}, err error) (interface{}, error) {
+	if err != nil || payload == nil {
+		return nil, err
+	}
+
+	switch payload.(type) {
+	case types.SharedModuleSet:
+		set := make([]sharedModulePayload, len(payload.(types.SharedModuleSet)))
+
+		for i, d := range payload.(types.SharedModuleSet) {
+			mp, _ := ctrl.makeSharedModulePayload(ctx, d, err)
+			set[i] = *mp
+		}
+
+		return set, err
+	case types.ExposedModuleSet:
+		set := make([]exposedModulePayload, len(payload.(types.ExposedModuleSet)))
+
+		for i, d := range payload.(types.ExposedModuleSet) {
+			mp, _ := ctrl.makeExposedModulePayload(ctx, d, err)
+			set[i] = *mp
+		}
+
+		return set, err
+	case types.ModuleMappingSet:
+		set := make([]moduleMappingPayload, len(payload.(types.ModuleMappingSet)))
+
+		for i, d := range payload.(types.ModuleMappingSet) {
+			mp, _ := ctrl.makeModuleMappingPayload(ctx, d, err)
+			set[i] = *mp
+		}
+
+		return set, err
+	case *types.ExposedModule:
+		return ctrl.makeExposedModulePayload(ctx, payload.(*types.ExposedModule), err)
+	case *types.SharedModule:
+		return ctrl.makeSharedModulePayload(ctx, payload.(*types.SharedModule), err)
+	default:
+		return nil, nil
+	}
+}

server/federation/rest/node.go

@@ -0,0 +1,156 @@
+package rest
+
+import (
+	"context"
+
+	"github.com/cortezaproject/corteza/server/federation/rest/request"
+	"github.com/cortezaproject/corteza/server/federation/service"
+	"github.com/cortezaproject/corteza/server/federation/types"
+	"github.com/cortezaproject/corteza/server/pkg/api"
+	"github.com/cortezaproject/corteza/server/pkg/filter"
+)
+
+type (
+	nodeServicer interface {
+		Search(ctx context.Context, f types.NodeFilter) (types.NodeSet, types.NodeFilter, error)
+		Create(ctx context.Context, n *types.Node) (*types.Node, error)
+		CreateFromPairingURI(ctx context.Context, uri string) (*types.Node, error)
+		Read(ctx context.Context, ID uint64) (*types.Node, error)
+		Update(ctx context.Context, n *types.Node) (*types.Node, error)
+		DeleteByID(ctx context.Context, ID uint64) error
+		UndeleteByID(ctx context.Context, ID uint64) error
+
+		Pair(ctx context.Context, nodeID uint64) error
+		HandshakeConfirm(ctx context.Context, nodeID uint64) error
+		HandshakeComplete(ctx context.Context, nodeID uint64, token string) error
+
+		RegenerateNodeURI(ctx context.Context, nodeID uint64) (string, error)
+	}
+
+	Node struct {
+		svcNode nodeServicer
+	}
+
+	moduleSetPayload struct {
+		Filter types.NodeFilter `json:"filter"`
+		Set    []*nodePayload   `json:"set"`
+	}
+
+	nodePayload struct {
+		*types.Node
+
+		CanManageNode   bool `json:"canManageNode"`
+		CanCreateModule bool `json:"canCreateModule"`
+	}
+)
+
+func (Node) New() *Node {
+	return &Node{
+		svcNode: service.DefaultNode,
+	}
+}
+
+func (ctrl Node) Search(ctx context.Context, r *request.NodeSearch) (interface{}, error) {
+	var (
+		err error
+		f   = types.NodeFilter{
+			Query:  r.Query,
+			Status: r.Status,
+		}
+	)
+
+	if f.Paging, err = filter.NewPaging(r.Limit, r.PageCursor); err != nil {
+		return nil, err
+	}
+
+	f.IncTotal = r.IncTotal
+
+	if f.Sorting, err = filter.NewSorting(r.Sort); err != nil {
+		return nil, err
+	}
+
+	set, f, err := ctrl.svcNode.Search(ctx, f)
+
+	return ctrl.makeFilterPayload(ctx, set, f, err)
+}
+
+func (ctrl Node) Create(ctx context.Context, r *request.NodeCreate) (interface{}, error) {
+	if r.PairingURI != "" {
+		return ctrl.svcNode.CreateFromPairingURI(ctx, r.PairingURI)
+	} else {
+		n := &types.Node{
+			BaseURL: r.BaseURL,
+			Name:    r.Name,
+			Contact: r.Contact,
+		}
+
+		n, err := ctrl.svcNode.Create(ctx, n)
+		return ctrl.makePayload(ctx, n, err)
+	}
+}
+
+func (ctrl Node) Read(ctx context.Context, r *request.NodeRead) (interface{}, error) {
+	n, err := ctrl.svcNode.Read(ctx, r.NodeID)
+
+	return ctrl.makePayload(ctx, n, err)
+}
+func (ctrl Node) Update(ctx context.Context, r *request.NodeUpdate) (interface{}, error) {
+	n, err := ctrl.svcNode.Update(ctx, &types.Node{
+		ID:      r.NodeID,
+		Name:    r.Name,
+		BaseURL: r.BaseURL,
+		Contact: r.Contact,
+	})
+
+	return ctrl.makePayload(ctx, n, err)
+}
+func (ctrl Node) Delete(ctx context.Context, r *request.NodeDelete) (interface{}, error) {
+	return api.OK(), ctrl.svcNode.DeleteByID(ctx, r.NodeID)
+}
+
+func (ctrl Node) Undelete(ctx context.Context, r *request.NodeUndelete) (interface{}, error) {
+	return api.OK(), ctrl.svcNode.UndeleteByID(ctx, r.NodeID)
+}
+
+func (ctrl Node) GenerateURI(ctx context.Context, r *request.NodeGenerateURI) (interface{}, error) {
+	return ctrl.svcNode.RegenerateNodeURI(ctx, r.NodeID)
+}
+
+func (ctrl Node) Pair(ctx context.Context, r *request.NodePair) (interface{}, error) {
+	return api.OK(), ctrl.svcNode.Pair(ctx, r.NodeID)
+}
+
+func (ctrl Node) HandshakeConfirm(ctx context.Context, r *request.NodeHandshakeConfirm) (interface{}, error) {
+	return api.OK(), ctrl.svcNode.HandshakeConfirm(ctx, r.NodeID)
+}
+
+func (ctrl Node) HandshakeComplete(ctx context.Context, r *request.NodeHandshakeComplete) (interface{}, error) {
+	return api.OK(), ctrl.svcNode.HandshakeComplete(ctx, r.NodeID, r.AuthToken)
+}
+
+func (ctrl Node) makePayload(ctx context.Context, m *types.Node, err error) (*nodePayload, error) {
+	if err != nil || m == nil {
+		return nil, err
+	}
+
+	return &nodePayload{
+		Node: m,
+
+		CanCreateModule: service.DefaultAccessControl.CanCreateModuleOnNode(ctx, m),
+		CanManageNode:   service.DefaultAccessControl.CanManageNode(ctx, m),
+	}, nil
+}
+
+func (ctrl Node) makeFilterPayload(ctx context.Context, nn types.NodeSet, f types.NodeFilter, err error) (*moduleSetPayload, error) {
+	if err != nil {
+		return nil, err
+	}
+
+	msp := &moduleSetPayload{Filter: f, Set: make([]*nodePayload, len(nn))}
+
+	for i := range nn {
+		msp.Set[i], _ = ctrl.makePayload(ctx, nn[i], nil)
+	}
+
+	return msp, nil
+}

server/federation/rest/node_handshake.go

@@ -0,0 +1,28 @@
+package rest
+
+import (
+	"context"
+	"github.com/cortezaproject/corteza/server/federation/rest/request"
+	"github.com/cortezaproject/corteza/server/federation/service"
+	"github.com/cortezaproject/corteza/server/pkg/api"
+)
+
+type (
+	handshakeInitializer interface {
+		HandshakeInit(context.Context, uint64, string, uint64, string) error
+	}
+
+	NodeHandshake struct {
+		svcNode handshakeInitializer
+	}
+)
+
+func (NodeHandshake) New() *NodeHandshake {
+	return &NodeHandshake{
+		svcNode: service.DefaultNode,
+	}
+}
+
+func (ctrl NodeHandshake) Initialize(ctx context.Context, r *request.NodeHandshakeInitialize) (interface{}, error) {
+	return api.OK(), ctrl.svcNode.HandshakeInit(ctx, r.NodeID, r.PairToken, r.SharedNodeID, r.AuthToken)
+}

server/federation/rest/permissions.go

@@ -0,0 +1,69 @@
+package rest
+
+import (
+	"context"
+	"github.com/cortezaproject/corteza/server/federation/rest/request"
+	"github.com/cortezaproject/corteza/server/federation/service"
+	"github.com/cortezaproject/corteza/server/federation/types"
+	"github.com/cortezaproject/corteza/server/pkg/api"
+	"github.com/cortezaproject/corteza/server/pkg/rbac"
+)
+
+type (
+	Permissions struct {
+		ac permissionsAccessController
+	}
+
+	permissionsAccessController interface {
+		Effective(context.Context, ...rbac.Resource) rbac.EffectiveSet
+		Trace(context.Context, uint64, []uint64, ...string) ([]*rbac.Trace, error)
+		List() []map[string]string
+		FindRulesByRoleID(context.Context, uint64) (rbac.RuleSet, error)
+		FindRules(ctx context.Context, roleID uint64, rr ...string) (rbac.RuleSet, error)
+		Grant(ctx context.Context, rr ...*rbac.Rule) error
+	}
+)
+
+func (Permissions) New() *Permissions {
+	return &Permissions{
+		ac: service.DefaultAccessControl,
+	}
+}
+
+func (ctrl Permissions) Effective(ctx context.Context, r *request.PermissionsEffective) (interface{}, error) {
+	return ctrl.ac.Effective(ctx, types.Component{}), nil
+}
+
+func (ctrl Permissions) Trace(ctx context.Context, r *request.PermissionsTrace) (interface{}, error) {
+	return ctrl.ac.Trace(ctx, r.UserID, r.RoleID, r.Resource...)
+}
+
+func (ctrl Permissions) List(ctx context.Context, r *request.PermissionsList) (interface{}, error) {
+	return ctrl.ac.List(), nil
+}
+
+func (ctrl Permissions) Read(ctx context.Context, r *request.PermissionsRead) (interface{}, error) {
+	return ctrl.ac.FindRules(ctx, r.RoleID, r.Resource...)
+}
+
+func (ctrl Permissions) Delete(ctx context.Context, r *request.PermissionsDelete) (interface{}, error) {
+	rr, err := ctrl.ac.FindRulesByRoleID(ctx, r.RoleID)
+	if err != nil {
+		return nil, err
+	}
+
+	for _, r := range rr {
+		r.Access = rbac.Inherit
+	}
+
+	return api.OK(), ctrl.ac.Grant(ctx, rr...)
+}
+
+func (ctrl Permissions) Update(ctx context.Context, r *request.PermissionsUpdate) (interface{}, error) {
+	for _, rule := range r.Rules {
+		// Make sure everything is properly set
+		rule.RoleID = r.RoleID
+	}
+
+	return api.OK(), ctrl.ac.Grant(ctx, r.Rules...)
+}

server/federation/rest/request/manageStructure.go

@@ -0,0 +1,945 @@
+package request
+
+// This file is auto-generated.
+//
+// Changes to this file may cause incorrect behavior and will be lost if
+// the code is regenerated.
+//
+// Definitions file that controls how this file is generated:
+//
+
+import (
+	"encoding/json"
+	"fmt"
+	"github.com/cortezaproject/corteza/server/federation/types"
+	"github.com/cortezaproject/corteza/server/pkg/payload"
+	"github.com/go-chi/chi/v5"
+	"io"
+	"mime/multipart"
+	"net/http"
+	"strings"
+)
+
+// dummy vars to prevent
+// unused imports complain
+var (
+	_ = chi.URLParam
+	_ = multipart.ErrMessageTooLarge
+	_ = payload.ParseUint64s
+	_ = strings.ToLower
+	_ = io.EOF
+	_ = fmt.Errorf
+	_ = json.NewEncoder
+)
+
+type (
+	// Internal API interface
+	ManageStructureReadExposed struct {
+		// NodeID PATH parameter
+		//
+		// Node ID
+		NodeID uint64 `json:",string"`
+
+		// ModuleID PATH parameter
+		//
+		// Module ID
+		ModuleID uint64 `json:",string"`
+	}
+
+	ManageStructureCreateExposed struct {
+		// NodeID PATH parameter
+		//
+		// Node ID
+		NodeID uint64 `json:",string"`
+
+		// ComposeModuleID POST parameter
+		//
+		// Compose module id
+		ComposeModuleID uint64 `json:",string"`
+
+		// ComposeNamespaceID POST parameter
+		//
+		// Compose namespace id
+		ComposeNamespaceID uint64 `json:",string"`
+
+		// Name POST parameter
+		//
+		// Module name
+		Name string
+
+		// Handle POST parameter
+		//
+		// Module handle
+		Handle string
+
+		// Fields POST parameter
+		//
+		// Exposed module fields
+		Fields types.ModuleFieldSet
+	}
+
+	ManageStructureUpdateExposed struct {
+		// NodeID PATH parameter
+		//
+		// Node ID
+		NodeID uint64 `json:",string"`
+
+		// ModuleID PATH parameter
+		//
+		// Module ID
+		ModuleID uint64 `json:",string"`
+
+		// ComposeModuleID POST parameter
+		//
+		// Compose module id
+		ComposeModuleID uint64 `json:",string"`
+
+		// ComposeNamespaceID POST parameter
+		//
+		// Compose namespace id
+		ComposeNamespaceID uint64 `json:",string"`
+
+		// Name POST parameter
+		//
+		// Module name
+		Name string
+
+		// Handle POST parameter
+		//
+		// Module handle
+		Handle string
+
+		// Fields POST parameter
+		//
+		// Exposed module fields
+		Fields types.ModuleFieldSet
+	}
+
+	ManageStructureRemoveExposed struct {
+		// NodeID PATH parameter
+		//
+		// Node ID
+		NodeID uint64 `json:",string"`
+
+		// ModuleID PATH parameter
+		//
+		// Module ID
+		ModuleID uint64 `json:",string"`
+	}
+
+	ManageStructureReadShared struct {
+		// NodeID PATH parameter
+		//
+		// Node ID
+		NodeID uint64 `json:",string"`
+
+		// ModuleID PATH parameter
+		//
+		// Module ID
+		ModuleID uint64 `json:",string"`
+	}
+
+	ManageStructureCreateMappings struct {
+		// NodeID PATH parameter
+		//
+		// Node ID
+		NodeID uint64 `json:",string"`
+
+		// ModuleID PATH parameter
+		//
+		// Module ID
+		ModuleID uint64 `json:",string"`
+
+		// ComposeModuleID POST parameter
+		//
+		// Compose module id
+		ComposeModuleID uint64 `json:",string"`
+
+		// ComposeNamespaceID POST parameter
+		//
+		// Compose namespace id
+		ComposeNamespaceID uint64 `json:",string"`
+
+		// Fields POST parameter
+		//
+		// Exposed module fields
+		Fields types.ModuleFieldMappingSet
+	}
+
+	ManageStructureReadMappings struct {
+		// NodeID PATH parameter
+		//
+		// Node ID
+		NodeID uint64 `json:",string"`
+
+		// ModuleID PATH parameter
+		//
+		// Module ID
+		ModuleID uint64 `json:",string"`
+
+		// ComposeModuleID GET parameter
+		//
+		// Compose module id
+		ComposeModuleID uint64 `json:",string"`
+	}
+
+	ManageStructureListAll struct {
+		// NodeID PATH parameter
+		//
+		// Node ID
+		NodeID uint64 `json:",string"`
+
+		// Shared GET parameter
+		//
+		// List shared modules
+		Shared bool
+
+		// Exposed GET parameter
+		//
+		// List exposed modules
+		Exposed bool
+
+		// Mapped GET parameter
+		//
+		// List mapped modules
+		Mapped bool
+	}
+)
+
+// NewManageStructureReadExposed request
+func NewManageStructureReadExposed() *ManageStructureReadExposed {
+	return &ManageStructureReadExposed{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ManageStructureReadExposed) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"nodeID":   r.NodeID,
+		"moduleID": r.ModuleID,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ManageStructureReadExposed) GetNodeID() uint64 {
+	return r.NodeID
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ManageStructureReadExposed) GetModuleID() uint64 {
+	return r.ModuleID
+}
+
+// Fill processes request and fills internal variables
+func (r *ManageStructureReadExposed) Fill(req *http.Request) (err error) {
+
+	{
+		var val string
+		// path params
+
+		val = chi.URLParam(req, "nodeID")
+		r.NodeID, err = payload.ParseUint64(val), nil
+		if err != nil {
+			return err
+		}
+
+		val = chi.URLParam(req, "moduleID")
+		r.ModuleID, err = payload.ParseUint64(val), nil
+		if err != nil {
+			return err
+		}
+
+	}
+
+	return err
+}
+
+// NewManageStructureCreateExposed request
+func NewManageStructureCreateExposed() *ManageStructureCreateExposed {
+	return &ManageStructureCreateExposed{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ManageStructureCreateExposed) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"nodeID":             r.NodeID,
+		"composeModuleID":    r.ComposeModuleID,
+		"composeNamespaceID": r.ComposeNamespaceID,
+		"name":               r.Name,
+		"handle":             r.Handle,
+		"fields":             r.Fields,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ManageStructureCreateExposed) GetNodeID() uint64 {
+	return r.NodeID
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ManageStructureCreateExposed) GetComposeModuleID() uint64 {
+	return r.ComposeModuleID
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ManageStructureCreateExposed) GetComposeNamespaceID() uint64 {
+	return r.ComposeNamespaceID
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ManageStructureCreateExposed) GetName() string {
+	return r.Name
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ManageStructureCreateExposed) GetHandle() string {
+	return r.Handle
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ManageStructureCreateExposed) GetFields() types.ModuleFieldSet {
+	return r.Fields
+}
+
+// Fill processes request and fills internal variables
+func (r *ManageStructureCreateExposed) Fill(req *http.Request) (err error) {
+
+	if strings.HasPrefix(strings.ToLower(req.Header.Get("content-type")), "application/json") {
+		err = json.NewDecoder(req.Body).Decode(r)
+
+		switch {
+		case err == io.EOF:
+			err = nil
+		case err != nil:
+			return fmt.Errorf("error parsing http request body: %w", err)
+		}
+	}
+
+	{
+		// Caching 32MB to memory, the rest to disk
+		if err = req.ParseMultipartForm(32 << 20); err != nil && err != http.ErrNotMultipart {
+			return err
+		} else if err == nil {
+			// Multipart params
+
+			if val, ok := req.MultipartForm.Value["composeModuleID"]; ok && len(val) > 0 {
+				r.ComposeModuleID, err = payload.ParseUint64(val[0]), nil
+				if err != nil {
+					return err
+				}
+			}
+
+			if val, ok := req.MultipartForm.Value["composeNamespaceID"]; ok && len(val) > 0 {
+				r.ComposeNamespaceID, err = payload.ParseUint64(val[0]), nil
+				if err != nil {
+					return err
+				}
+			}
+
+			if val, ok := req.MultipartForm.Value["name"]; ok && len(val) > 0 {
+				r.Name, err = val[0], nil
+				if err != nil {
+					return err
+				}
+			}
+
+			if val, ok := req.MultipartForm.Value["handle"]; ok && len(val) > 0 {
+				r.Handle, err = val[0], nil
+				if err != nil {
+					return err
+				}
+			}
+
+		}
+	}
+
+	{
+		if err = req.ParseForm(); err != nil {
+			return err
+		}
+
+		// POST params
+
+		if val, ok := req.Form["composeModuleID"]; ok && len(val) > 0 {
+			r.ComposeModuleID, err = payload.ParseUint64(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+
+		if val, ok := req.Form["composeNamespaceID"]; ok && len(val) > 0 {
+			r.ComposeNamespaceID, err = payload.ParseUint64(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+
+		if val, ok := req.Form["name"]; ok && len(val) > 0 {
+			r.Name, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+
+		if val, ok := req.Form["handle"]; ok && len(val) > 0 {
+			r.Handle, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+
+		//if val, ok := req.Form["fields[]"]; ok && len(val) > 0  {
+		//    r.Fields, err = types.ModuleFieldSet(val), nil
+		//    if err != nil {
+		//        return err
+		//    }
+		//}
+	}
+
+	{
+		var val string
+		// path params
+
+		val = chi.URLParam(req, "nodeID")
+		r.NodeID, err = payload.ParseUint64(val), nil
+		if err != nil {
+			return err
+		}
+
+	}
+
+	return err
+}
+
+// NewManageStructureUpdateExposed request
+func NewManageStructureUpdateExposed() *ManageStructureUpdateExposed {
+	return &ManageStructureUpdateExposed{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ManageStructureUpdateExposed) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"nodeID":             r.NodeID,
+		"moduleID":           r.ModuleID,
+		"composeModuleID":    r.ComposeModuleID,
+		"composeNamespaceID": r.ComposeNamespaceID,
+		"name":               r.Name,
+		"handle":             r.Handle,
+		"fields":             r.Fields,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ManageStructureUpdateExposed) GetNodeID() uint64 {
+	return r.NodeID
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ManageStructureUpdateExposed) GetModuleID() uint64 {
+	return r.ModuleID
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ManageStructureUpdateExposed) GetComposeModuleID() uint64 {
+	return r.ComposeModuleID
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ManageStructureUpdateExposed) GetComposeNamespaceID() uint64 {
+	return r.ComposeNamespaceID
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ManageStructureUpdateExposed) GetName() string {
+	return r.Name
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ManageStructureUpdateExposed) GetHandle() string {
+	return r.Handle
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ManageStructureUpdateExposed) GetFields() types.ModuleFieldSet {
+	return r.Fields
+}
+
+// Fill processes request and fills internal variables
+func (r *ManageStructureUpdateExposed) Fill(req *http.Request) (err error) {
+
+	if strings.HasPrefix(strings.ToLower(req.Header.Get("content-type")), "application/json") {
+		err = json.NewDecoder(req.Body).Decode(r)
+
+		switch {
+		case err == io.EOF:
+			err = nil
+		case err != nil:
+			return fmt.Errorf("error parsing http request body: %w", err)
+		}
+	}
+
+	{
+		// Caching 32MB to memory, the rest to disk
+		if err = req.ParseMultipartForm(32 << 20); err != nil && err != http.ErrNotMultipart {
+			return err
+		} else if err == nil {
+			// Multipart params
+
+			if val, ok := req.MultipartForm.Value["composeModuleID"]; ok && len(val) > 0 {
+				r.ComposeModuleID, err = payload.ParseUint64(val[0]), nil
+				if err != nil {
+					return err
+				}
+			}
+
+			if val, ok := req.MultipartForm.Value["composeNamespaceID"]; ok && len(val) > 0 {
+				r.ComposeNamespaceID, err = payload.ParseUint64(val[0]), nil
+				if err != nil {
+					return err
+				}
+			}
+
+			if val, ok := req.MultipartForm.Value["name"]; ok && len(val) > 0 {
+				r.Name, err = val[0], nil
+				if err != nil {
+					return err
+				}
+			}
+
+			if val, ok := req.MultipartForm.Value["handle"]; ok && len(val) > 0 {
+				r.Handle, err = val[0], nil
+				if err != nil {
+					return err
+				}
+			}
+
+		}
+	}
+
+	{
+		if err = req.ParseForm(); err != nil {
+			return err
+		}
+
+		// POST params
+
+		if val, ok := req.Form["composeModuleID"]; ok && len(val) > 0 {
+			r.ComposeModuleID, err = payload.ParseUint64(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+
+		if val, ok := req.Form["composeNamespaceID"]; ok && len(val) > 0 {
+			r.ComposeNamespaceID, err = payload.ParseUint64(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+
+		if val, ok := req.Form["name"]; ok && len(val) > 0 {
+			r.Name, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+
+		if val, ok := req.Form["handle"]; ok && len(val) > 0 {
+			r.Handle, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+
+		//if val, ok := req.Form["fields[]"]; ok && len(val) > 0  {
+		//    r.Fields, err = types.ModuleFieldSet(val), nil
+		//    if err != nil {
+		//        return err
+		//    }
+		//}
+	}
+
+	{
+		var val string
+		// path params
+
+		val = chi.URLParam(req, "nodeID")
+		r.NodeID, err = payload.ParseUint64(val), nil
+		if err != nil {
+			return err
+		}
+
+		val = chi.URLParam(req, "moduleID")
+		r.ModuleID, err = payload.ParseUint64(val), nil
+		if err != nil {
+			return err
+		}
+
+	}
+
+	return err
+}
+
+// NewManageStructureRemoveExposed request
+func NewManageStructureRemoveExposed() *ManageStructureRemoveExposed {
+	return &ManageStructureRemoveExposed{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ManageStructureRemoveExposed) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"nodeID":   r.NodeID,
+		"moduleID": r.ModuleID,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ManageStructureRemoveExposed) GetNodeID() uint64 {
+	return r.NodeID
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ManageStructureRemoveExposed) GetModuleID() uint64 {
+	return r.ModuleID
+}
+
+// Fill processes request and fills internal variables
+func (r *ManageStructureRemoveExposed) Fill(req *http.Request) (err error) {
+
+	{
+		var val string
+		// path params
+
+		val = chi.URLParam(req, "nodeID")
+		r.NodeID, err = payload.ParseUint64(val), nil
+		if err != nil {
+			return err
+		}
+
+		val = chi.URLParam(req, "moduleID")
+		r.ModuleID, err = payload.ParseUint64(val), nil
+		if err != nil {
+			return err
+		}
+
+	}
+
+	return err
+}
+
+// NewManageStructureReadShared request
+func NewManageStructureReadShared() *ManageStructureReadShared {
+	return &ManageStructureReadShared{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ManageStructureReadShared) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"nodeID":   r.NodeID,
+		"moduleID": r.ModuleID,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ManageStructureReadShared) GetNodeID() uint64 {
+	return r.NodeID
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ManageStructureReadShared) GetModuleID() uint64 {
+	return r.ModuleID
+}
+
+// Fill processes request and fills internal variables
+func (r *ManageStructureReadShared) Fill(req *http.Request) (err error) {
+
+	{
+		var val string
+		// path params
+
+		val = chi.URLParam(req, "nodeID")
+		r.NodeID, err = payload.ParseUint64(val), nil
+		if err != nil {
+			return err
+		}
+
+		val = chi.URLParam(req, "moduleID")
+		r.ModuleID, err = payload.ParseUint64(val), nil
+		if err != nil {
+			return err
+		}
+
+	}
+
+	return err
+}
+
+// NewManageStructureCreateMappings request
+func NewManageStructureCreateMappings() *ManageStructureCreateMappings {
+	return &ManageStructureCreateMappings{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ManageStructureCreateMappings) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"nodeID":             r.NodeID,
+		"moduleID":           r.ModuleID,
+		"composeModuleID":    r.ComposeModuleID,
+		"composeNamespaceID": r.ComposeNamespaceID,
+		"fields":             r.Fields,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ManageStructureCreateMappings) GetNodeID() uint64 {
+	return r.NodeID
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ManageStructureCreateMappings) GetModuleID() uint64 {
+	return r.ModuleID
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ManageStructureCreateMappings) GetComposeModuleID() uint64 {
+	return r.ComposeModuleID
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ManageStructureCreateMappings) GetComposeNamespaceID() uint64 {
+	return r.ComposeNamespaceID
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ManageStructureCreateMappings) GetFields() types.ModuleFieldMappingSet {
+	return r.Fields
+}
+
+// Fill processes request and fills internal variables
+func (r *ManageStructureCreateMappings) Fill(req *http.Request) (err error) {
+
+	if strings.HasPrefix(strings.ToLower(req.Header.Get("content-type")), "application/json") {
+		err = json.NewDecoder(req.Body).Decode(r)
+
+		switch {
+		case err == io.EOF:
+			err = nil
+		case err != nil:
+			return fmt.Errorf("error parsing http request body: %w", err)
+		}
+	}
+
+	{
+		// Caching 32MB to memory, the rest to disk
+		if err = req.ParseMultipartForm(32 << 20); err != nil && err != http.ErrNotMultipart {
+			return err
+		} else if err == nil {
+			// Multipart params
+
+			if val, ok := req.MultipartForm.Value["composeModuleID"]; ok && len(val) > 0 {
+				r.ComposeModuleID, err = payload.ParseUint64(val[0]), nil
+				if err != nil {
+					return err
+				}
+			}
+
+			if val, ok := req.MultipartForm.Value["composeNamespaceID"]; ok && len(val) > 0 {
+				r.ComposeNamespaceID, err = payload.ParseUint64(val[0]), nil
+				if err != nil {
+					return err
+				}
+			}
+
+		}
+	}
+
+	{
+		if err = req.ParseForm(); err != nil {
+			return err
+		}
+
+		// POST params
+
+		if val, ok := req.Form["composeModuleID"]; ok && len(val) > 0 {
+			r.ComposeModuleID, err = payload.ParseUint64(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+
+		if val, ok := req.Form["composeNamespaceID"]; ok && len(val) > 0 {
+			r.ComposeNamespaceID, err = payload.ParseUint64(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+
+		//if val, ok := req.Form["fields[]"]; ok && len(val) > 0  {
+		//    r.Fields, err = types.ModuleFieldMappingSet(val), nil
+		//    if err != nil {
+		//        return err
+		//    }
+		//}
+	}
+
+	{
+		var val string
+		// path params
+
+		val = chi.URLParam(req, "nodeID")
+		r.NodeID, err = payload.ParseUint64(val), nil
+		if err != nil {
+			return err
+		}
+
+		val = chi.URLParam(req, "moduleID")
+		r.ModuleID, err = payload.ParseUint64(val), nil
+		if err != nil {
+			return err
+		}
+
+	}
+
+	return err
+}
+
+// NewManageStructureReadMappings request
+func NewManageStructureReadMappings() *ManageStructureReadMappings {
+	return &ManageStructureReadMappings{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ManageStructureReadMappings) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"nodeID":          r.NodeID,
+		"moduleID":        r.ModuleID,
+		"composeModuleID": r.ComposeModuleID,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ManageStructureReadMappings) GetNodeID() uint64 {
+	return r.NodeID
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ManageStructureReadMappings) GetModuleID() uint64 {
+	return r.ModuleID
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ManageStructureReadMappings) GetComposeModuleID() uint64 {
+	return r.ComposeModuleID
+}
+
+// Fill processes request and fills internal variables
+func (r *ManageStructureReadMappings) Fill(req *http.Request) (err error) {
+
+	{
+		// GET params
+		tmp := req.URL.Query()
+
+		if val, ok := tmp["composeModuleID"]; ok && len(val) > 0 {
+			r.ComposeModuleID, err = payload.ParseUint64(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+	}
+
+	{
+		var val string
+		// path params
+
+		val = chi.URLParam(req, "nodeID")
+		r.NodeID, err = payload.ParseUint64(val), nil
+		if err != nil {
+			return err
+		}
+
+		val = chi.URLParam(req, "moduleID")
+		r.ModuleID, err = payload.ParseUint64(val), nil
+		if err != nil {
+			return err
+		}
+
+	}
+
+	return err
+}
+
+// NewManageStructureListAll request
+func NewManageStructureListAll() *ManageStructureListAll {
+	return &ManageStructureListAll{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ManageStructureListAll) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"nodeID":  r.NodeID,
+		"shared":  r.Shared,
+		"exposed": r.Exposed,
+		"mapped":  r.Mapped,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ManageStructureListAll) GetNodeID() uint64 {
+	return r.NodeID
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ManageStructureListAll) GetShared() bool {
+	return r.Shared
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ManageStructureListAll) GetExposed() bool {
+	return r.Exposed
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ManageStructureListAll) GetMapped() bool {
+	return r.Mapped
+}
+
+// Fill processes request and fills internal variables
+func (r *ManageStructureListAll) Fill(req *http.Request) (err error) {
+
+	{
+		// GET params
+		tmp := req.URL.Query()
+
+		if val, ok := tmp["shared"]; ok && len(val) > 0 {
+			r.Shared, err = payload.ParseBool(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["exposed"]; ok && len(val) > 0 {
+			r.Exposed, err = payload.ParseBool(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["mapped"]; ok && len(val) > 0 {
+			r.Mapped, err = payload.ParseBool(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+	}
+
+	{
+		var val string
+		// path params
+
+		val = chi.URLParam(req, "nodeID")
+		r.NodeID, err = payload.ParseUint64(val), nil
+		if err != nil {
+			return err
+		}
+
+	}
+
+	return err
+}

server/federation/rest/request/node.go

@@ -0,0 +1,801 @@
+package request
+
+// This file is auto-generated.
+//
+// Changes to this file may cause incorrect behavior and will be lost if
+// the code is regenerated.
+//
+// Definitions file that controls how this file is generated:
+//
+
+import (
+	"encoding/json"
+	"fmt"
+	"github.com/cortezaproject/corteza/server/pkg/payload"
+	"github.com/go-chi/chi/v5"
+	"io"
+	"mime/multipart"
+	"net/http"
+	"strings"
+)
+
+// dummy vars to prevent
+// unused imports complain
+var (
+	_ = chi.URLParam
+	_ = multipart.ErrMessageTooLarge
+	_ = payload.ParseUint64s
+	_ = strings.ToLower
+	_ = io.EOF
+	_ = fmt.Errorf
+	_ = json.NewEncoder
+)
+
+type (
+	// Internal API interface
+	NodeSearch struct {
+		// Query GET parameter
+		//
+		// Filter nodes by name and host
+		Query string
+
+		// Status GET parameter
+		//
+		// Filter by status
+		Status string
+
+		// Limit GET parameter
+		//
+		// Limit
+		Limit uint
+
+		// IncTotal GET parameter
+		//
+		// Include total counter
+		IncTotal bool
+
+		// PageCursor GET parameter
+		//
+		// Page cursor
+		PageCursor string
+
+		// Sort GET parameter
+		//
+		// Sort items
+		Sort string
+	}
+
+	NodeCreate struct {
+		// BaseURL POST parameter
+		//
+		// Federation API base URL
+		BaseURL string
+
+		// Name POST parameter
+		//
+		// Name for this node
+		Name string
+
+		// Contact POST parameter
+		//
+		// Contact email
+		Contact string
+
+		// PairingURI POST parameter
+		//
+		// Pairing URI
+		PairingURI string
+	}
+
+	NodeRead struct {
+		// NodeID PATH parameter
+		//
+		// NodeID
+		NodeID uint64 `json:",string"`
+	}
+
+	NodeGenerateURI struct {
+		// NodeID PATH parameter
+		//
+		// NodeID
+		NodeID uint64 `json:",string"`
+	}
+
+	NodeUpdate struct {
+		// NodeID PATH parameter
+		//
+		// NodeID
+		NodeID uint64 `json:",string"`
+
+		// Name POST parameter
+		//
+		// Name for this node
+		Name string
+
+		// Contact POST parameter
+		//
+		// Contact email
+		Contact string
+
+		// BaseURL POST parameter
+		//
+		// Federation API base URL
+		BaseURL string
+	}
+
+	NodeDelete struct {
+		// NodeID PATH parameter
+		//
+		// NodeID
+		NodeID uint64 `json:",string"`
+	}
+
+	NodeUndelete struct {
+		// NodeID PATH parameter
+		//
+		// NodeID
+		NodeID uint64 `json:",string"`
+	}
+
+	NodePair struct {
+		// NodeID PATH parameter
+		//
+		// NodeID
+		NodeID uint64 `json:",string"`
+	}
+
+	NodeHandshakeConfirm struct {
+		// NodeID PATH parameter
+		//
+		// NodeID
+		NodeID uint64 `json:",string"`
+	}
+
+	NodeHandshakeComplete struct {
+		// NodeID PATH parameter
+		//
+		// NodeID
+		NodeID uint64 `json:",string"`
+
+		// AuthToken POST parameter
+		//
+		// Node A token
+		AuthToken string
+	}
+)
+
+// NewNodeSearch request
+func NewNodeSearch() *NodeSearch {
+	return &NodeSearch{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r NodeSearch) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"query":      r.Query,
+		"status":     r.Status,
+		"limit":      r.Limit,
+		"incTotal":   r.IncTotal,
+		"pageCursor": r.PageCursor,
+		"sort":       r.Sort,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r NodeSearch) GetQuery() string {
+	return r.Query
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r NodeSearch) GetStatus() string {
+	return r.Status
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r NodeSearch) GetLimit() uint {
+	return r.Limit
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r NodeSearch) GetIncTotal() bool {
+	return r.IncTotal
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r NodeSearch) GetPageCursor() string {
+	return r.PageCursor
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r NodeSearch) GetSort() string {
+	return r.Sort
+}
+
+// Fill processes request and fills internal variables
+func (r *NodeSearch) Fill(req *http.Request) (err error) {
+
+	{
+		// GET params
+		tmp := req.URL.Query()
+
+		if val, ok := tmp["query"]; ok && len(val) > 0 {
+			r.Query, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["status"]; ok && len(val) > 0 {
+			r.Status, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["limit"]; ok && len(val) > 0 {
+			r.Limit, err = payload.ParseUint(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["incTotal"]; ok && len(val) > 0 {
+			r.IncTotal, err = payload.ParseBool(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["pageCursor"]; ok && len(val) > 0 {
+			r.PageCursor, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["sort"]; ok && len(val) > 0 {
+			r.Sort, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+	}
+
+	return err
+}
+
+// NewNodeCreate request
+func NewNodeCreate() *NodeCreate {
+	return &NodeCreate{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r NodeCreate) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"baseURL":    r.BaseURL,
+		"name":       r.Name,
+		"contact":    r.Contact,
+		"pairingURI": r.PairingURI,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r NodeCreate) GetBaseURL() string {
+	return r.BaseURL
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r NodeCreate) GetName() string {
+	return r.Name
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r NodeCreate) GetContact() string {
+	return r.Contact
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r NodeCreate) GetPairingURI() string {
+	return r.PairingURI
+}
+
+// Fill processes request and fills internal variables
+func (r *NodeCreate) Fill(req *http.Request) (err error) {
+
+	if strings.HasPrefix(strings.ToLower(req.Header.Get("content-type")), "application/json") {
+		err = json.NewDecoder(req.Body).Decode(r)
+
+		switch {
+		case err == io.EOF:
+			err = nil
+		case err != nil:
+			return fmt.Errorf("error parsing http request body: %w", err)
+		}
+	}
+
+	{
+		// Caching 32MB to memory, the rest to disk
+		if err = req.ParseMultipartForm(32 << 20); err != nil && err != http.ErrNotMultipart {
+			return err
+		} else if err == nil {
+			// Multipart params
+
+			if val, ok := req.MultipartForm.Value["baseURL"]; ok && len(val) > 0 {
+				r.BaseURL, err = val[0], nil
+				if err != nil {
+					return err
+				}
+			}
+
+			if val, ok := req.MultipartForm.Value["name"]; ok && len(val) > 0 {
+				r.Name, err = val[0], nil
+				if err != nil {
+					return err
+				}
+			}
+
+			if val, ok := req.MultipartForm.Value["contact"]; ok && len(val) > 0 {
+				r.Contact, err = val[0], nil
+				if err != nil {
+					return err
+				}
+			}
+
+			if val, ok := req.MultipartForm.Value["pairingURI"]; ok && len(val) > 0 {
+				r.PairingURI, err = val[0], nil
+				if err != nil {
+					return err
+				}
+			}
+		}
+	}
+
+	{
+		if err = req.ParseForm(); err != nil {
+			return err
+		}
+
+		// POST params
+
+		if val, ok := req.Form["baseURL"]; ok && len(val) > 0 {
+			r.BaseURL, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+
+		if val, ok := req.Form["name"]; ok && len(val) > 0 {
+			r.Name, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+
+		if val, ok := req.Form["contact"]; ok && len(val) > 0 {
+			r.Contact, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+
+		if val, ok := req.Form["pairingURI"]; ok && len(val) > 0 {
+			r.PairingURI, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+	}
+
+	return err
+}
+
+// NewNodeRead request
+func NewNodeRead() *NodeRead {
+	return &NodeRead{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r NodeRead) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"nodeID": r.NodeID,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r NodeRead) GetNodeID() uint64 {
+	return r.NodeID
+}
+
+// Fill processes request and fills internal variables
+func (r *NodeRead) Fill(req *http.Request) (err error) {
+
+	{
+		var val string
+		// path params
+
+		val = chi.URLParam(req, "nodeID")
+		r.NodeID, err = payload.ParseUint64(val), nil
+		if err != nil {
+			return err
+		}
+
+	}
+
+	return err
+}
+
+// NewNodeGenerateURI request
+func NewNodeGenerateURI() *NodeGenerateURI {
+	return &NodeGenerateURI{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r NodeGenerateURI) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"nodeID": r.NodeID,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r NodeGenerateURI) GetNodeID() uint64 {
+	return r.NodeID
+}
+
+// Fill processes request and fills internal variables
+func (r *NodeGenerateURI) Fill(req *http.Request) (err error) {
+
+	{
+		var val string
+		// path params
+
+		val = chi.URLParam(req, "nodeID")
+		r.NodeID, err = payload.ParseUint64(val), nil
+		if err != nil {
+			return err
+		}
+
+	}
+
+	return err
+}
+
+// NewNodeUpdate request
+func NewNodeUpdate() *NodeUpdate {
+	return &NodeUpdate{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r NodeUpdate) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"nodeID":  r.NodeID,
+		"name":    r.Name,
+		"contact": r.Contact,
+		"baseURL": r.BaseURL,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r NodeUpdate) GetNodeID() uint64 {
+	return r.NodeID
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r NodeUpdate) GetName() string {
+	return r.Name
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r NodeUpdate) GetContact() string {
+	return r.Contact
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r NodeUpdate) GetBaseURL() string {
+	return r.BaseURL
+}
+
+// Fill processes request and fills internal variables
+func (r *NodeUpdate) Fill(req *http.Request) (err error) {
+
+	if strings.HasPrefix(strings.ToLower(req.Header.Get("content-type")), "application/json") {
+		err = json.NewDecoder(req.Body).Decode(r)
+
+		switch {
+		case err == io.EOF:
+			err = nil
+		case err != nil:
+			return fmt.Errorf("error parsing http request body: %w", err)
+		}
+	}
+
+	{
+		// Caching 32MB to memory, the rest to disk
+		if err = req.ParseMultipartForm(32 << 20); err != nil && err != http.ErrNotMultipart {
+			return err
+		} else if err == nil {
+			// Multipart params
+
+			if val, ok := req.MultipartForm.Value["name"]; ok && len(val) > 0 {
+				r.Name, err = val[0], nil
+				if err != nil {
+					return err
+				}
+			}
+
+			if val, ok := req.MultipartForm.Value["contact"]; ok && len(val) > 0 {
+				r.Contact, err = val[0], nil
+				if err != nil {
+					return err
+				}
+			}
+
+			if val, ok := req.MultipartForm.Value["baseURL"]; ok && len(val) > 0 {
+				r.BaseURL, err = val[0], nil
+				if err != nil {
+					return err
+				}
+			}
+		}
+	}
+
+	{
+		if err = req.ParseForm(); err != nil {
+			return err
+		}
+
+		// POST params
+
+		if val, ok := req.Form["name"]; ok && len(val) > 0 {
+			r.Name, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+
+		if val, ok := req.Form["contact"]; ok && len(val) > 0 {
+			r.Contact, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+
+		if val, ok := req.Form["baseURL"]; ok && len(val) > 0 {
+			r.BaseURL, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+	}
+
+	{
+		var val string
+		// path params
+
+		val = chi.URLParam(req, "nodeID")
+		r.NodeID, err = payload.ParseUint64(val), nil
+		if err != nil {
+			return err
+		}
+
+	}
+
+	return err
+}
+
+// NewNodeDelete request
+func NewNodeDelete() *NodeDelete {
+	return &NodeDelete{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r NodeDelete) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"nodeID": r.NodeID,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r NodeDelete) GetNodeID() uint64 {
+	return r.NodeID
+}
+
+// Fill processes request and fills internal variables
+func (r *NodeDelete) Fill(req *http.Request) (err error) {
+
+	{
+		var val string
+		// path params
+
+		val = chi.URLParam(req, "nodeID")
+		r.NodeID, err = payload.ParseUint64(val), nil
+		if err != nil {
+			return err
+		}
+
+	}
+
+	return err
+}
+
+// NewNodeUndelete request
+func NewNodeUndelete() *NodeUndelete {
+	return &NodeUndelete{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r NodeUndelete) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"nodeID": r.NodeID,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r NodeUndelete) GetNodeID() uint64 {
+	return r.NodeID
+}
+
+// Fill processes request and fills internal variables
+func (r *NodeUndelete) Fill(req *http.Request) (err error) {
+
+	{
+		var val string
+		// path params
+
+		val = chi.URLParam(req, "nodeID")
+		r.NodeID, err = payload.ParseUint64(val), nil
+		if err != nil {
+			return err
+		}
+
+	}
+
+	return err
+}
+
+// NewNodePair request
+func NewNodePair() *NodePair {
+	return &NodePair{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r NodePair) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"nodeID": r.NodeID,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r NodePair) GetNodeID() uint64 {
+	return r.NodeID
+}
+
+// Fill processes request and fills internal variables
+func (r *NodePair) Fill(req *http.Request) (err error) {
+
+	{
+		var val string
+		// path params
+
+		val = chi.URLParam(req, "nodeID")
+		r.NodeID, err = payload.ParseUint64(val), nil
+		if err != nil {
+			return err
+		}
+
+	}
+
+	return err
+}
+
+// NewNodeHandshakeConfirm request
+func NewNodeHandshakeConfirm() *NodeHandshakeConfirm {
+	return &NodeHandshakeConfirm{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r NodeHandshakeConfirm) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"nodeID": r.NodeID,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r NodeHandshakeConfirm) GetNodeID() uint64 {
+	return r.NodeID
+}
+
+// Fill processes request and fills internal variables
+func (r *NodeHandshakeConfirm) Fill(req *http.Request) (err error) {
+
+	{
+		var val string
+		// path params
+
+		val = chi.URLParam(req, "nodeID")
+		r.NodeID, err = payload.ParseUint64(val), nil
+		if err != nil {
+			return err
+		}
+
+	}
+
+	return err
+}
+
+// NewNodeHandshakeComplete request
+func NewNodeHandshakeComplete() *NodeHandshakeComplete {
+	return &NodeHandshakeComplete{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r NodeHandshakeComplete) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"nodeID":    r.NodeID,
+		"authToken": r.AuthToken,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r NodeHandshakeComplete) GetNodeID() uint64 {
+	return r.NodeID
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r NodeHandshakeComplete) GetAuthToken() string {
+	return r.AuthToken
+}
+
+// Fill processes request and fills internal variables
+func (r *NodeHandshakeComplete) Fill(req *http.Request) (err error) {
+
+	if strings.HasPrefix(strings.ToLower(req.Header.Get("content-type")), "application/json") {
+		err = json.NewDecoder(req.Body).Decode(r)
+
+		switch {
+		case err == io.EOF:
+			err = nil
+		case err != nil:
+			return fmt.Errorf("error parsing http request body: %w", err)
+		}
+	}
+
+	{
+		// Caching 32MB to memory, the rest to disk
+		if err = req.ParseMultipartForm(32 << 20); err != nil && err != http.ErrNotMultipart {
+			return err
+		} else if err == nil {
+			// Multipart params
+
+			if val, ok := req.MultipartForm.Value["authToken"]; ok && len(val) > 0 {
+				r.AuthToken, err = val[0], nil
+				if err != nil {
+					return err
+				}
+			}
+		}
+	}
+
+	{
+		if err = req.ParseForm(); err != nil {
+			return err
+		}
+
+		// POST params
+
+		if val, ok := req.Form["authToken"]; ok && len(val) > 0 {
+			r.AuthToken, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+	}
+
+	{
+		var val string
+		// path params
+
+		val = chi.URLParam(req, "nodeID")
+		r.NodeID, err = payload.ParseUint64(val), nil
+		if err != nil {
+			return err
+		}
+
+	}
+
+	return err
+}

server/federation/rest/request/nodeHandshake.go

@@ -0,0 +1,180 @@
+package request
+
+// This file is auto-generated.
+//
+// Changes to this file may cause incorrect behavior and will be lost if
+// the code is regenerated.
+//
+// Definitions file that controls how this file is generated:
+//
+
+import (
+	"encoding/json"
+	"fmt"
+	"github.com/cortezaproject/corteza/server/pkg/payload"
+	"github.com/go-chi/chi/v5"
+	"io"
+	"mime/multipart"
+	"net/http"
+	"strings"
+)
+
+// dummy vars to prevent
+// unused imports complain
+var (
+	_ = chi.URLParam
+	_ = multipart.ErrMessageTooLarge
+	_ = payload.ParseUint64s
+	_ = strings.ToLower
+	_ = io.EOF
+	_ = fmt.Errorf
+	_ = json.NewEncoder
+)
+
+type (
+	// Internal API interface
+	NodeHandshakeInitialize struct {
+		// NodeID PATH parameter
+		//
+		// NodeID
+		NodeID uint64 `json:",string"`
+
+		// PairToken POST parameter
+		//
+		// Pairing token to authenticate handshake initialization request
+		PairToken string
+
+		// SharedNodeID POST parameter
+		//
+		// Remote (invoker's) node ID
+		SharedNodeID uint64 `json:",string"`
+
+		// AuthToken POST parameter
+		//
+		// Authentication token so that remote
+		AuthToken string
+	}
+)
+
+// NewNodeHandshakeInitialize request
+func NewNodeHandshakeInitialize() *NodeHandshakeInitialize {
+	return &NodeHandshakeInitialize{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r NodeHandshakeInitialize) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"nodeID":       r.NodeID,
+		"pairToken":    r.PairToken,
+		"sharedNodeID": r.SharedNodeID,
+		"authToken":    r.AuthToken,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r NodeHandshakeInitialize) GetNodeID() uint64 {
+	return r.NodeID
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r NodeHandshakeInitialize) GetPairToken() string {
+	return r.PairToken
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r NodeHandshakeInitialize) GetSharedNodeID() uint64 {
+	return r.SharedNodeID
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r NodeHandshakeInitialize) GetAuthToken() string {
+	return r.AuthToken
+}
+
+// Fill processes request and fills internal variables
+func (r *NodeHandshakeInitialize) Fill(req *http.Request) (err error) {
+
+	if strings.HasPrefix(strings.ToLower(req.Header.Get("content-type")), "application/json") {
+		err = json.NewDecoder(req.Body).Decode(r)
+
+		switch {
+		case err == io.EOF:
+			err = nil
+		case err != nil:
+			return fmt.Errorf("error parsing http request body: %w", err)
+		}
+	}
+
+	{
+		// Caching 32MB to memory, the rest to disk
+		if err = req.ParseMultipartForm(32 << 20); err != nil && err != http.ErrNotMultipart {
+			return err
+		} else if err == nil {
+			// Multipart params
+
+			if val, ok := req.MultipartForm.Value["pairToken"]; ok && len(val) > 0 {
+				r.PairToken, err = val[0], nil
+				if err != nil {
+					return err
+				}
+			}
+
+			if val, ok := req.MultipartForm.Value["sharedNodeID"]; ok && len(val) > 0 {
+				r.SharedNodeID, err = payload.ParseUint64(val[0]), nil
+				if err != nil {
+					return err
+				}
+			}
+
+			if val, ok := req.MultipartForm.Value["authToken"]; ok && len(val) > 0 {
+				r.AuthToken, err = val[0], nil
+				if err != nil {
+					return err
+				}
+			}
+		}
+	}
+
+	{
+		if err = req.ParseForm(); err != nil {
+			return err
+		}
+
+		// POST params
+
+		if val, ok := req.Form["pairToken"]; ok && len(val) > 0 {
+			r.PairToken, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+
+		if val, ok := req.Form["sharedNodeID"]; ok && len(val) > 0 {
+			r.SharedNodeID, err = payload.ParseUint64(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+
+		if val, ok := req.Form["authToken"]; ok && len(val) > 0 {
+			r.AuthToken, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+	}
+
+	{
+		var val string
+		// path params
+
+		val = chi.URLParam(req, "nodeID")
+		r.NodeID, err = payload.ParseUint64(val), nil
+		if err != nil {
+			return err
+		}
+
+	}
+
+	return err
+}

server/federation/rest/request/permissions.go

@@ -0,0 +1,384 @@
+package request
+
+// This file is auto-generated.
+//
+// Changes to this file may cause incorrect behavior and will be lost if
+// the code is regenerated.
+//
+// Definitions file that controls how this file is generated:
+//
+
+import (
+	"encoding/json"
+	"fmt"
+	"github.com/cortezaproject/corteza/server/pkg/payload"
+	"github.com/cortezaproject/corteza/server/pkg/rbac"
+	"github.com/go-chi/chi/v5"
+	"io"
+	"mime/multipart"
+	"net/http"
+	"strings"
+)
+
+// dummy vars to prevent
+// unused imports complain
+var (
+	_ = chi.URLParam
+	_ = multipart.ErrMessageTooLarge
+	_ = payload.ParseUint64s
+	_ = strings.ToLower
+	_ = io.EOF
+	_ = fmt.Errorf
+	_ = json.NewEncoder
+)
+
+type (
+	// Internal API interface
+	PermissionsList struct {
+	}
+
+	PermissionsEffective struct {
+		// Resource GET parameter
+		//
+		// Show only rules for a specific resource
+		Resource string
+	}
+
+	PermissionsTrace struct {
+		// Resource GET parameter
+		//
+		// Show only rules for a specific resource
+		Resource []string
+
+		// UserID GET parameter
+		//
+		//
+		UserID uint64 `json:",string"`
+
+		// RoleID GET parameter
+		//
+		//
+		RoleID []uint64
+	}
+
+	PermissionsRead struct {
+		// RoleID PATH parameter
+		//
+		// Role ID
+		RoleID uint64 `json:",string"`
+
+		// Resource GET parameter
+		//
+		// Show only rules for a specific resource
+		Resource []string
+	}
+
+	PermissionsDelete struct {
+		// RoleID PATH parameter
+		//
+		// Role ID
+		RoleID uint64 `json:",string"`
+	}
+
+	PermissionsUpdate struct {
+		// RoleID PATH parameter
+		//
+		// Role ID
+		RoleID uint64 `json:",string"`
+
+		// Rules POST parameter
+		//
+		// List of permission rules to set
+		Rules rbac.RuleSet
+	}
+)
+
+// NewPermissionsList request
+func NewPermissionsList() *PermissionsList {
+	return &PermissionsList{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r PermissionsList) Auditable() map[string]interface{} {
+	return map[string]interface{}{}
+}
+
+// Fill processes request and fills internal variables
+func (r *PermissionsList) Fill(req *http.Request) (err error) {
+
+	return err
+}
+
+// NewPermissionsEffective request
+func NewPermissionsEffective() *PermissionsEffective {
+	return &PermissionsEffective{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r PermissionsEffective) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"resource": r.Resource,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r PermissionsEffective) GetResource() string {
+	return r.Resource
+}
+
+// Fill processes request and fills internal variables
+func (r *PermissionsEffective) Fill(req *http.Request) (err error) {
+
+	{
+		// GET params
+		tmp := req.URL.Query()
+
+		if val, ok := tmp["resource"]; ok && len(val) > 0 {
+			r.Resource, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+	}
+
+	return err
+}
+
+// NewPermissionsTrace request
+func NewPermissionsTrace() *PermissionsTrace {
+	return &PermissionsTrace{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r PermissionsTrace) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"resource": r.Resource,
+		"userID":   r.UserID,
+		"roleID":   r.RoleID,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r PermissionsTrace) GetResource() []string {
+	return r.Resource
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r PermissionsTrace) GetUserID() uint64 {
+	return r.UserID
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r PermissionsTrace) GetRoleID() []uint64 {
+	return r.RoleID
+}
+
+// Fill processes request and fills internal variables
+func (r *PermissionsTrace) Fill(req *http.Request) (err error) {
+
+	{
+		// GET params
+		tmp := req.URL.Query()
+
+		if val, ok := tmp["resource[]"]; ok {
+			r.Resource, err = val, nil
+			if err != nil {
+				return err
+			}
+		} else if val, ok := tmp["resource"]; ok {
+			r.Resource, err = val, nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["userID"]; ok && len(val) > 0 {
+			r.UserID, err = payload.ParseUint64(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["roleID[]"]; ok {
+			r.RoleID, err = payload.ParseUint64s(val), nil
+			if err != nil {
+				return err
+			}
+		} else if val, ok := tmp["roleID"]; ok {
+			r.RoleID, err = payload.ParseUint64s(val), nil
+			if err != nil {
+				return err
+			}
+		}
+	}
+
+	return err
+}
+
+// NewPermissionsRead request
+func NewPermissionsRead() *PermissionsRead {
+	return &PermissionsRead{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r PermissionsRead) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"roleID":   r.RoleID,
+		"resource": r.Resource,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r PermissionsRead) GetRoleID() uint64 {
+	return r.RoleID
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r PermissionsRead) GetResource() []string {
+	return r.Resource
+}
+
+// Fill processes request and fills internal variables
+func (r *PermissionsRead) Fill(req *http.Request) (err error) {
+
+	{
+		// GET params
+		tmp := req.URL.Query()
+
+		if val, ok := tmp["resource[]"]; ok {
+			r.Resource, err = val, nil
+			if err != nil {
+				return err
+			}
+		} else if val, ok := tmp["resource"]; ok {
+			r.Resource, err = val, nil
+			if err != nil {
+				return err
+			}
+		}
+	}
+
+	{
+		var val string
+		// path params
+
+		val = chi.URLParam(req, "roleID")
+		r.RoleID, err = payload.ParseUint64(val), nil
+		if err != nil {
+			return err
+		}
+
+	}
+
+	return err
+}
+
+// NewPermissionsDelete request
+func NewPermissionsDelete() *PermissionsDelete {
+	return &PermissionsDelete{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r PermissionsDelete) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"roleID": r.RoleID,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r PermissionsDelete) GetRoleID() uint64 {
+	return r.RoleID
+}
+
+// Fill processes request and fills internal variables
+func (r *PermissionsDelete) Fill(req *http.Request) (err error) {
+
+	{
+		var val string
+		// path params
+
+		val = chi.URLParam(req, "roleID")
+		r.RoleID, err = payload.ParseUint64(val), nil
+		if err != nil {
+			return err
+		}
+
+	}
+
+	return err
+}
+
+// NewPermissionsUpdate request
+func NewPermissionsUpdate() *PermissionsUpdate {
+	return &PermissionsUpdate{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r PermissionsUpdate) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"roleID": r.RoleID,
+		"rules":  r.Rules,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r PermissionsUpdate) GetRoleID() uint64 {
+	return r.RoleID
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r PermissionsUpdate) GetRules() rbac.RuleSet {
+	return r.Rules
+}
+
+// Fill processes request and fills internal variables
+func (r *PermissionsUpdate) Fill(req *http.Request) (err error) {
+
+	if strings.HasPrefix(strings.ToLower(req.Header.Get("content-type")), "application/json") {
+		err = json.NewDecoder(req.Body).Decode(r)
+
+		switch {
+		case err == io.EOF:
+			err = nil
+		case err != nil:
+			return fmt.Errorf("error parsing http request body: %w", err)
+		}
+	}
+
+	{
+		// Caching 32MB to memory, the rest to disk
+		if err = req.ParseMultipartForm(32 << 20); err != nil && err != http.ErrNotMultipart {
+			return err
+		} else if err == nil {
+			// Multipart params
+
+		}
+	}
+
+	{
+		if err = req.ParseForm(); err != nil {
+			return err
+		}
+
+		// POST params
+
+		//if val, ok := req.Form["rules[]"]; ok && len(val) > 0  {
+		//    r.Rules, err = rbac.RuleSet(val), nil
+		//    if err != nil {
+		//        return err
+		//    }
+		//}
+	}
+
+	{
+		var val string
+		// path params
+
+		val = chi.URLParam(req, "roleID")
+		r.RoleID, err = payload.ParseUint64(val), nil
+		if err != nil {
+			return err
+		}
+
+	}
+
+	return err
+}

server/federation/rest/request/syncData.go

@@ -0,0 +1,468 @@
+package request
+
+// This file is auto-generated.
+//
+// Changes to this file may cause incorrect behavior and will be lost if
+// the code is regenerated.
+//
+// Definitions file that controls how this file is generated:
+//
+
+import (
+	"encoding/json"
+	"fmt"
+	"github.com/cortezaproject/corteza/server/pkg/payload"
+	"github.com/go-chi/chi/v5"
+	"io"
+	"mime/multipart"
+	"net/http"
+	"strings"
+)
+
+// dummy vars to prevent
+// unused imports complain
+var (
+	_ = chi.URLParam
+	_ = multipart.ErrMessageTooLarge
+	_ = payload.ParseUint64s
+	_ = strings.ToLower
+	_ = io.EOF
+	_ = fmt.Errorf
+	_ = json.NewEncoder
+)
+
+type (
+	// Internal API interface
+	SyncDataReadExposedAll struct {
+		// NodeID PATH parameter
+		//
+		// Node ID
+		NodeID uint64 `json:",string"`
+
+		// LastSync GET parameter
+		//
+		// Last sync timestamp
+		LastSync uint64 `json:",string"`
+
+		// Query GET parameter
+		//
+		// Search query
+		Query string
+
+		// Limit GET parameter
+		//
+		// Limit
+		Limit uint
+
+		// PageCursor GET parameter
+		//
+		// Page cursor
+		PageCursor string
+
+		// Sort GET parameter
+		//
+		// Sort items
+		Sort string
+	}
+
+	SyncDataReadExposedInternal struct {
+		// NodeID PATH parameter
+		//
+		// Node ID
+		NodeID uint64 `json:",string"`
+
+		// ModuleID PATH parameter
+		//
+		// Module ID
+		ModuleID uint64 `json:",string"`
+
+		// LastSync GET parameter
+		//
+		// Last sync timestamp
+		LastSync uint64 `json:",string"`
+
+		// Query GET parameter
+		//
+		// Search query
+		Query string
+
+		// Limit GET parameter
+		//
+		// Limit
+		Limit uint
+
+		// PageCursor GET parameter
+		//
+		// Page cursor
+		PageCursor string
+
+		// Sort GET parameter
+		//
+		// Sort items
+		Sort string
+	}
+
+	SyncDataReadExposedSocial struct {
+		// NodeID PATH parameter
+		//
+		// Node ID
+		NodeID uint64 `json:",string"`
+
+		// ModuleID PATH parameter
+		//
+		// Module ID
+		ModuleID uint64 `json:",string"`
+
+		// LastSync GET parameter
+		//
+		// Last sync timestamp
+		LastSync uint64 `json:",string"`
+
+		// Query GET parameter
+		//
+		// Search query
+		Query string
+
+		// Limit GET parameter
+		//
+		// Limit
+		Limit uint
+
+		// PageCursor GET parameter
+		//
+		// Page cursor
+		PageCursor string
+
+		// Sort GET parameter
+		//
+		// Sort items
+		Sort string
+	}
+)
+
+// NewSyncDataReadExposedAll request
+func NewSyncDataReadExposedAll() *SyncDataReadExposedAll {
+	return &SyncDataReadExposedAll{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r SyncDataReadExposedAll) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"nodeID":     r.NodeID,
+		"lastSync":   r.LastSync,
+		"query":      r.Query,
+		"limit":      r.Limit,
+		"pageCursor": r.PageCursor,
+		"sort":       r.Sort,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r SyncDataReadExposedAll) GetNodeID() uint64 {
+	return r.NodeID
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r SyncDataReadExposedAll) GetLastSync() uint64 {
+	return r.LastSync
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r SyncDataReadExposedAll) GetQuery() string {
+	return r.Query
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r SyncDataReadExposedAll) GetLimit() uint {
+	return r.Limit
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r SyncDataReadExposedAll) GetPageCursor() string {
+	return r.PageCursor
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r SyncDataReadExposedAll) GetSort() string {
+	return r.Sort
+}
+
+// Fill processes request and fills internal variables
+func (r *SyncDataReadExposedAll) Fill(req *http.Request) (err error) {
+
+	{
+		// GET params
+		tmp := req.URL.Query()
+
+		if val, ok := tmp["lastSync"]; ok && len(val) > 0 {
+			r.LastSync, err = payload.ParseUint64(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["query"]; ok && len(val) > 0 {
+			r.Query, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["limit"]; ok && len(val) > 0 {
+			r.Limit, err = payload.ParseUint(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["pageCursor"]; ok && len(val) > 0 {
+			r.PageCursor, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["sort"]; ok && len(val) > 0 {
+			r.Sort, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+	}
+
+	{
+		var val string
+		// path params
+
+		val = chi.URLParam(req, "nodeID")
+		r.NodeID, err = payload.ParseUint64(val), nil
+		if err != nil {
+			return err
+		}
+
+	}
+
+	return err
+}
+
+// NewSyncDataReadExposedInternal request
+func NewSyncDataReadExposedInternal() *SyncDataReadExposedInternal {
+	return &SyncDataReadExposedInternal{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r SyncDataReadExposedInternal) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"nodeID":     r.NodeID,
+		"moduleID":   r.ModuleID,
+		"lastSync":   r.LastSync,
+		"query":      r.Query,
+		"limit":      r.Limit,
+		"pageCursor": r.PageCursor,
+		"sort":       r.Sort,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r SyncDataReadExposedInternal) GetNodeID() uint64 {
+	return r.NodeID
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r SyncDataReadExposedInternal) GetModuleID() uint64 {
+	return r.ModuleID
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r SyncDataReadExposedInternal) GetLastSync() uint64 {
+	return r.LastSync
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r SyncDataReadExposedInternal) GetQuery() string {
+	return r.Query
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r SyncDataReadExposedInternal) GetLimit() uint {
+	return r.Limit
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r SyncDataReadExposedInternal) GetPageCursor() string {
+	return r.PageCursor
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r SyncDataReadExposedInternal) GetSort() string {
+	return r.Sort
+}
+
+// Fill processes request and fills internal variables
+func (r *SyncDataReadExposedInternal) Fill(req *http.Request) (err error) {
+
+	{
+		// GET params
+		tmp := req.URL.Query()
+
+		if val, ok := tmp["lastSync"]; ok && len(val) > 0 {
+			r.LastSync, err = payload.ParseUint64(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["query"]; ok && len(val) > 0 {
+			r.Query, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["limit"]; ok && len(val) > 0 {
+			r.Limit, err = payload.ParseUint(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["pageCursor"]; ok && len(val) > 0 {
+			r.PageCursor, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["sort"]; ok && len(val) > 0 {
+			r.Sort, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+	}
+
+	{
+		var val string
+		// path params
+
+		val = chi.URLParam(req, "nodeID")
+		r.NodeID, err = payload.ParseUint64(val), nil
+		if err != nil {
+			return err
+		}
+
+		val = chi.URLParam(req, "moduleID")
+		r.ModuleID, err = payload.ParseUint64(val), nil
+		if err != nil {
+			return err
+		}
+
+	}
+
+	return err
+}
+
+// NewSyncDataReadExposedSocial request
+func NewSyncDataReadExposedSocial() *SyncDataReadExposedSocial {
+	return &SyncDataReadExposedSocial{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r SyncDataReadExposedSocial) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"nodeID":     r.NodeID,
+		"moduleID":   r.ModuleID,
+		"lastSync":   r.LastSync,
+		"query":      r.Query,
+		"limit":      r.Limit,
+		"pageCursor": r.PageCursor,
+		"sort":       r.Sort,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r SyncDataReadExposedSocial) GetNodeID() uint64 {
+	return r.NodeID
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r SyncDataReadExposedSocial) GetModuleID() uint64 {
+	return r.ModuleID
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r SyncDataReadExposedSocial) GetLastSync() uint64 {
+	return r.LastSync
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r SyncDataReadExposedSocial) GetQuery() string {
+	return r.Query
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r SyncDataReadExposedSocial) GetLimit() uint {
+	return r.Limit
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r SyncDataReadExposedSocial) GetPageCursor() string {
+	return r.PageCursor
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r SyncDataReadExposedSocial) GetSort() string {
+	return r.Sort
+}
+
+// Fill processes request and fills internal variables
+func (r *SyncDataReadExposedSocial) Fill(req *http.Request) (err error) {
+
+	{
+		// GET params
+		tmp := req.URL.Query()
+
+		if val, ok := tmp["lastSync"]; ok && len(val) > 0 {
+			r.LastSync, err = payload.ParseUint64(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["query"]; ok && len(val) > 0 {
+			r.Query, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["limit"]; ok && len(val) > 0 {
+			r.Limit, err = payload.ParseUint(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["pageCursor"]; ok && len(val) > 0 {
+			r.PageCursor, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["sort"]; ok && len(val) > 0 {
+			r.Sort, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+	}
+
+	{
+		var val string
+		// path params
+
+		val = chi.URLParam(req, "nodeID")
+		r.NodeID, err = payload.ParseUint64(val), nil
+		if err != nil {
+			return err
+		}
+
+		val = chi.URLParam(req, "moduleID")
+		r.ModuleID, err = payload.ParseUint64(val), nil
+		if err != nil {
+			return err
+		}
+
+	}
+
+	return err
+}

server/federation/rest/request/syncStructure.go

@@ -0,0 +1,301 @@
+package request
+
+// This file is auto-generated.
+//
+// Changes to this file may cause incorrect behavior and will be lost if
+// the code is regenerated.
+//
+// Definitions file that controls how this file is generated:
+//
+
+import (
+	"encoding/json"
+	"fmt"
+	"github.com/cortezaproject/corteza/server/pkg/payload"
+	"github.com/go-chi/chi/v5"
+	"io"
+	"mime/multipart"
+	"net/http"
+	"strings"
+)
+
+// dummy vars to prevent
+// unused imports complain
+var (
+	_ = chi.URLParam
+	_ = multipart.ErrMessageTooLarge
+	_ = payload.ParseUint64s
+	_ = strings.ToLower
+	_ = io.EOF
+	_ = fmt.Errorf
+	_ = json.NewEncoder
+)
+
+type (
+	// Internal API interface
+	SyncStructureReadExposedInternal struct {
+		// NodeID PATH parameter
+		//
+		// Node ID
+		NodeID uint64 `json:",string"`
+
+		// LastSync GET parameter
+		//
+		// Last sync timestamp
+		LastSync uint64 `json:",string"`
+
+		// Query GET parameter
+		//
+		// Search query
+		Query string
+
+		// Limit GET parameter
+		//
+		// Limit
+		Limit uint
+
+		// PageCursor GET parameter
+		//
+		// Page cursor
+		PageCursor string
+
+		// Sort GET parameter
+		//
+		// Sort items
+		Sort string
+	}
+
+	SyncStructureReadExposedSocial struct {
+		// NodeID PATH parameter
+		//
+		// Node ID
+		NodeID uint64 `json:",string"`
+
+		// LastSync GET parameter
+		//
+		// Last sync timestamp
+		LastSync uint64 `json:",string"`
+
+		// Query GET parameter
+		//
+		// Search query
+		Query string
+
+		// Limit GET parameter
+		//
+		// Limit
+		Limit uint
+
+		// PageCursor GET parameter
+		//
+		// Page cursor
+		PageCursor string
+
+		// Sort GET parameter
+		//
+		// Sort items
+		Sort string
+	}
+)
+
+// NewSyncStructureReadExposedInternal request
+func NewSyncStructureReadExposedInternal() *SyncStructureReadExposedInternal {
+	return &SyncStructureReadExposedInternal{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r SyncStructureReadExposedInternal) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"nodeID":     r.NodeID,
+		"lastSync":   r.LastSync,
+		"query":      r.Query,
+		"limit":      r.Limit,
+		"pageCursor": r.PageCursor,
+		"sort":       r.Sort,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r SyncStructureReadExposedInternal) GetNodeID() uint64 {
+	return r.NodeID
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r SyncStructureReadExposedInternal) GetLastSync() uint64 {
+	return r.LastSync
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r SyncStructureReadExposedInternal) GetQuery() string {
+	return r.Query
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r SyncStructureReadExposedInternal) GetLimit() uint {
+	return r.Limit
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r SyncStructureReadExposedInternal) GetPageCursor() string {
+	return r.PageCursor
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r SyncStructureReadExposedInternal) GetSort() string {
+	return r.Sort
+}
+
+// Fill processes request and fills internal variables
+func (r *SyncStructureReadExposedInternal) Fill(req *http.Request) (err error) {
+
+	{
+		// GET params
+		tmp := req.URL.Query()
+
+		if val, ok := tmp["lastSync"]; ok && len(val) > 0 {
+			r.LastSync, err = payload.ParseUint64(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["query"]; ok && len(val) > 0 {
+			r.Query, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["limit"]; ok && len(val) > 0 {
+			r.Limit, err = payload.ParseUint(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["pageCursor"]; ok && len(val) > 0 {
+			r.PageCursor, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["sort"]; ok && len(val) > 0 {
+			r.Sort, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+	}
+
+	{
+		var val string
+		// path params
+
+		val = chi.URLParam(req, "nodeID")
+		r.NodeID, err = payload.ParseUint64(val), nil
+		if err != nil {
+			return err
+		}
+
+	}
+
+	return err
+}
+
+// NewSyncStructureReadExposedSocial request
+func NewSyncStructureReadExposedSocial() *SyncStructureReadExposedSocial {
+	return &SyncStructureReadExposedSocial{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r SyncStructureReadExposedSocial) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"nodeID":     r.NodeID,
+		"lastSync":   r.LastSync,
+		"query":      r.Query,
+		"limit":      r.Limit,
+		"pageCursor": r.PageCursor,
+		"sort":       r.Sort,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r SyncStructureReadExposedSocial) GetNodeID() uint64 {
+	return r.NodeID
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r SyncStructureReadExposedSocial) GetLastSync() uint64 {
+	return r.LastSync
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r SyncStructureReadExposedSocial) GetQuery() string {
+	return r.Query
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r SyncStructureReadExposedSocial) GetLimit() uint {
+	return r.Limit
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r SyncStructureReadExposedSocial) GetPageCursor() string {
+	return r.PageCursor
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r SyncStructureReadExposedSocial) GetSort() string {
+	return r.Sort
+}
+
+// Fill processes request and fills internal variables
+func (r *SyncStructureReadExposedSocial) Fill(req *http.Request) (err error) {
+
+	{
+		// GET params
+		tmp := req.URL.Query()
+
+		if val, ok := tmp["lastSync"]; ok && len(val) > 0 {
+			r.LastSync, err = payload.ParseUint64(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["query"]; ok && len(val) > 0 {
+			r.Query, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["limit"]; ok && len(val) > 0 {
+			r.Limit, err = payload.ParseUint(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["pageCursor"]; ok && len(val) > 0 {
+			r.PageCursor, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["sort"]; ok && len(val) > 0 {
+			r.Sort, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+	}
+
+	{
+		var val string
+		// path params
+
+		val = chi.URLParam(req, "nodeID")
+		r.NodeID, err = payload.ParseUint64(val), nil
+		if err != nil {
+			return err
+		}
+
+	}
+
+	return err
+}

server/federation/rest/router.go

@@ -0,0 +1,30 @@
+package rest
+
+import (
+	"github.com/cortezaproject/corteza/server/pkg/options"
+	"github.com/go-chi/chi/v5"
+
+	"github.com/cortezaproject/corteza/server/federation/rest/handlers"
+	"github.com/cortezaproject/corteza/server/pkg/auth"
+)
+
+func MountRoutes(opts options.LimitOpt) func(r chi.Router) {
+	return func(r chi.Router) {
+		r.Group(func(r chi.Router) {
+			handlers.NewNodeHandshake(NodeHandshake{}.New()).MountRoutes(r)
+		})
+
+		// Protect all _private_ routes
+		r.Group(func(r chi.Router) {
+			r.Use(auth.HttpTokenValidator("api"))
+
+			handlers.NewPermissions(Permissions{}.New()).MountRoutes(r)
+
+			handlers.NewNode(Node{}.New()).MountRoutes(r)
+			handlers.NewManageStructure((ManageStructure{}.New())).MountRoutes(r)
+
+			handlers.NewSyncData((SyncData{}.New(opts))).MountRoutes(r)
+			handlers.NewSyncStructure((SyncStructure{}.New())).MountRoutes(r)
+		})
+	}
+}

server/federation/rest/sync_data.go

@@ -0,0 +1,301 @@
+package rest
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"strings"
+	"time"
+
+	"github.com/cortezaproject/corteza/server/pkg/options"
+
+	cs "github.com/cortezaproject/corteza/server/compose/service"
+	ct "github.com/cortezaproject/corteza/server/compose/types"
+	"github.com/cortezaproject/corteza/server/federation/rest/request"
+	"github.com/cortezaproject/corteza/server/federation/service"
+	"github.com/cortezaproject/corteza/server/federation/types"
+	"github.com/cortezaproject/corteza/server/pkg/auth"
+	"github.com/cortezaproject/corteza/server/pkg/errors"
+	"github.com/cortezaproject/corteza/server/pkg/federation"
+	"github.com/cortezaproject/corteza/server/pkg/filter"
+	ss "github.com/cortezaproject/corteza/server/system/service"
+	st "github.com/cortezaproject/corteza/server/system/types"
+)
+
+type (
+	SyncData struct {
+		opts options.LimitOpt
+	}
+
+	recordPayload struct {
+		*ct.Record
+
+		Records ct.RecordSet `json:"records,omitempty"`
+
+		CanUpdateRecord bool `json:"canUpdateRecord"`
+		CanDeleteRecord bool `json:"canDeleteRecord"`
+	}
+
+	listRecordResponse struct {
+		Filter *ct.RecordFilter `json:"filter,omitempty"`
+		Set    *ct.RecordSet    `json:"set"`
+	}
+
+	listResponse struct {
+		Set *responseSet `json:"set"`
+	}
+
+	responseSet []*moduleResponse
+
+	moduleResponse struct {
+		Type string `json:"type"`
+		Rel  string `json:"rel"`
+		Href string `json:"href"`
+	}
+)
+
+func (SyncData) New(opts options.LimitOpt) *SyncData {
+	return &SyncData{
+		opts: opts,
+	}
+}
+
+func (ctrl SyncData) ReadExposedAll(ctx context.Context, r *request.SyncDataReadExposedAll) (interface{}, error) {
+	// todo - handle paging
+	var (
+		err  error
+		node *types.Node
+	)
+
+	if node, err = service.DefaultNode.FindBySharedNodeID(ctx, r.NodeID); err != nil {
+		return nil, err
+	}
+
+	s, _, err := service.DefaultExposedModule.Find(ctx, types.ExposedModuleFilter{NodeID: node.ID})
+
+	if err != nil {
+		return nil, err
+	}
+
+	composeModuleList := make(map[uint64][]uint64, len(s))
+
+	err = s.Walk(func(em *types.ExposedModule) error {
+		composeModuleList[em.ComposeModuleID] = []uint64{em.ComposeNamespaceID, em.ID}
+		return nil
+	})
+
+	if err != nil || len(composeModuleList) == 0 {
+		return nil, err
+	}
+
+	recordQuery := buildLastSyncQuery(r.LastSync)
+	responseSet := responseSet{}
+
+	for composeModuleID, idList := range composeModuleList {
+		rf := ct.RecordFilter{
+			NamespaceID: idList[0],
+			ModuleID:    composeModuleID,
+			Query:       recordQuery,
+			Paging:      filter.Paging{Limit: 1},
+		}
+
+		// todo - handle error properly
+		// @todo !!!
+		if list, _, err := (cs.Record(cs.RecordOptions{LimitRecords: ctrl.opts.RecordCountPerModule})).Find(ctx, rf); err != nil || len(list) == 0 {
+			continue
+		}
+
+		// generate url
+		moduleResponse := &moduleResponse{
+			Type: "GET",
+			Rel:  "Federation Module",
+			Href: fmt.Sprintf("/nodes/%d/modules/%d/records/", node.ID, idList[1]),
+		}
+
+		responseSet = append(responseSet, moduleResponse)
+	}
+
+	return listResponse{&responseSet}, nil
+}
+
+// ReadExposedInternal fetches all the data - records (with paging)
+// for an exposed module in an internal format
+func (ctrl SyncData) ReadExposedInternal(ctx context.Context, r *request.SyncDataReadExposedInternal) (interface{}, error) {
+	return func(w http.ResponseWriter, req *http.Request) {
+		payload, err := ctrl.readExposed(ctx, r)
+
+		if err != nil {
+			errors.ServeHTTP(w, req, err, false)
+			return
+		}
+
+		fEncoder := federation.NewEncoder(w, service.DefaultOptions)
+
+		err = fEncoder.Encode(payload, federation.CortezaInternalData)
+
+		if err != nil {
+			errors.ServeHTTP(w, req, err, false)
+			return
+		}
+
+		return
+	}, nil
+}
+
+// ReadExposedInternal fetches all the data - records (with paging)
+// for an exposed module in activity streams format
+func (ctrl SyncData) ReadExposedSocial(ctx context.Context, r *request.SyncDataReadExposedSocial) (interface{}, error) {
+	return func(w http.ResponseWriter, req *http.Request) {
+		rr := request.SyncDataReadExposedInternal{
+			NodeID:     r.NodeID,
+			ModuleID:   r.ModuleID,
+			LastSync:   r.LastSync,
+			Query:      r.Query,
+			Limit:      r.Limit,
+			PageCursor: r.PageCursor,
+			Sort:       r.Sort,
+		}
+
+		payload, err := ctrl.readExposed(ctx, &rr)
+
+		if err != nil {
+			errors.ServeHTTP(w, req, err, false)
+			return
+		}
+
+		fEncoder := federation.NewEncoder(w, service.DefaultOptions)
+
+		err = fEncoder.Encode(payload, federation.ActivityStreamsData)
+
+		if err != nil {
+			errors.ServeHTTP(w, req, err, false)
+			return
+		}
+
+		return
+	}, nil
+}
+
+// readExposed fetches all the data - records (with paging) for an exposed module in an internal format
+func (ctrl SyncData) readExposed(ctx context.Context, r *request.SyncDataReadExposedInternal) (interface{}, error) {
+	var (
+		err   error
+		em    *types.ExposedModule
+		users st.UserSet
+		node  *types.Node
+	)
+
+	if node, err = service.DefaultNode.FindBySharedNodeID(ctx, r.NodeID); err != nil {
+		return nil, err
+	}
+
+	if em, err = service.DefaultExposedModule.FindByID(ctx, r.NodeID, r.ModuleID); err != nil {
+		return nil, err
+	}
+
+	if users, _, err = ss.DefaultUser.Find(ctx, st.UserFilter{}); err != nil {
+		return nil, err
+	}
+
+	users, _ = users.Filter(func(u *st.User) (bool, error) {
+		return strings.Contains(u.Handle, "federation_"), nil
+	})
+
+	users = append(users, auth.FederationUser())
+
+	query := buildLastSyncQuery(r.LastSync)
+	ignoredUsersQuery := buildIgnoredUsersQuery(users)
+
+	if ignoredUsersQuery != "" {
+		if query != "" {
+			query += fmt.Sprintf(" AND %s", ignoredUsersQuery)
+		} else {
+			query = ignoredUsersQuery
+		}
+	}
+
+	f := ct.RecordFilter{
+		NamespaceID: em.ComposeNamespaceID,
+		ModuleID:    em.ComposeModuleID,
+		Query:       query,
+		Deleted:     filter.StateInclusive,
+	}
+
+	if f.Paging, err = filter.NewPaging(r.Limit, r.PageCursor); err != nil {
+		return nil, err
+	}
+
+	if f.Sorting, err = filter.NewSorting(r.Sort); err != nil {
+		return nil, err
+	}
+
+	// @todo !!!
+	list, f, err := (cs.Record(cs.RecordOptions{LimitRecords: ctrl.opts.RecordCountPerModule})).Find(ctx, f)
+
+	if err != nil {
+		return nil, err
+	}
+
+	// do the actual field filtering
+	err = list.Walk(filterExposedFields(em))
+
+	if err != nil {
+		return nil, err
+	}
+
+	return federation.ListDataPayload{
+		NodeID:   node.ID,
+		ModuleID: em.ID,
+		Filter:   &f,
+		Set:      &list,
+	}, nil
+}
+
+func buildLastSyncQuery(ts uint64) string {
+	if ts == 0 {
+		return ""
+	}
+
+	t := time.Unix(int64(ts), 0)
+
+	if t.IsZero() {
+		return ""
+	}
+
+	return fmt.Sprintf(
+		"(updated_at >= '%s' OR created_at >= '%s' OR deleted_at >= '%s')",
+		t.UTC().Format(time.RFC3339),
+		t.UTC().Format(time.RFC3339),
+		t.UTC().Format(time.RFC3339))
+}
+
+func buildIgnoredUsersQuery(users st.UserSet) string {
+	query := ""
+
+	if len(users) == 0 {
+		return query
+	}
+
+	for i, u := range users {
+		query += fmt.Sprintf("createdBy != %d", u.ID)
+
+		if i < len(users)-1 {
+			query += " AND "
+		}
+	}
+
+	return fmt.Sprintf("(%s)", query)
+}
+
+// filterExposedFields omits the fields that are not exposed as defined
+// in the exposed module definition in store
+func filterExposedFields(em *types.ExposedModule) func(r *ct.Record) error {
+	return func(r *ct.Record) error {
+		var err error
+		r.Values, err = r.Values.Filter(func(rv *ct.RecordValue) (bool, error) {
+			return em.Fields.HasField(rv.Name)
+		})
+
+		return err
+	}
+}

server/federation/rest/sync_structure.go

@@ -0,0 +1,129 @@
+package rest
+
+import (
+	"context"
+	"net/http"
+
+	"github.com/cortezaproject/corteza/server/federation/rest/request"
+	"github.com/cortezaproject/corteza/server/federation/service"
+	"github.com/cortezaproject/corteza/server/federation/types"
+	"github.com/cortezaproject/corteza/server/pkg/errors"
+	"github.com/cortezaproject/corteza/server/pkg/federation"
+	"github.com/cortezaproject/corteza/server/pkg/filter"
+)
+
+type (
+	SyncStructure struct{}
+)
+
+func (SyncStructure) New() *SyncStructure {
+	return &SyncStructure{}
+}
+
+// ReadExposedInternal gets the exposed module info and serves
+// the internal Corteza format of the structure
+func (ctrl SyncStructure) ReadExposedInternal(ctx context.Context, r *request.SyncStructureReadExposedInternal) (interface{}, error) {
+	return func(w http.ResponseWriter, req *http.Request) {
+		var (
+			err error
+			ef  federation.EncodingFormat = federation.CortezaInternalStructure
+		)
+
+		w.Header().Add("Content-Type", "application/json")
+
+		fEncoder := federation.NewEncoder(w, service.DefaultOptions)
+
+		payload, err := ctrl.readExposedAll(ctx, r)
+
+		if err != nil {
+			errors.ServeHTTP(w, req, err, false)
+			return
+		}
+
+		err = fEncoder.Encode(*payload, ef)
+
+		if err != nil {
+			errors.ServeHTTP(w, req, err, false)
+			return
+		}
+
+		return
+	}, nil
+}
+
+// ReadExposedSocial gets the exposed module info and serves
+// the activity streams format of the structure
+func (ctrl SyncStructure) ReadExposedSocial(ctx context.Context, r *request.SyncStructureReadExposedSocial) (interface{}, error) {
+	return func(w http.ResponseWriter, req *http.Request) {
+		var (
+			err error
+			ef  federation.EncodingFormat = federation.ActivityStreamsStructure
+		)
+
+		w.Header().Add("Content-Type", "application/json")
+
+		fEncoder := federation.NewEncoder(w, service.DefaultOptions)
+
+		rr := request.SyncStructureReadExposedInternal{
+			NodeID:     r.NodeID,
+			LastSync:   r.LastSync,
+			Query:      r.Query,
+			Limit:      r.Limit,
+			PageCursor: r.PageCursor,
+			Sort:       r.Sort,
+		}
+
+		payload, err := ctrl.readExposedAll(ctx, &rr)
+
+		if err != nil {
+			errors.ServeHTTP(w, req, err, false)
+			return
+		}
+
+		err = fEncoder.Encode(*payload, ef)
+
+		if err != nil {
+			errors.ServeHTTP(w, req, err, false)
+			return
+		}
+
+		return
+	}, nil
+}
+
+// readExposedAll fetches the exposed modules for the specific node
+func (ctrl SyncStructure) readExposedAll(ctx context.Context, r *request.SyncStructureReadExposedInternal) (*federation.ListStructurePayload, error) {
+	var (
+		err  error
+		node *types.Node
+	)
+
+	if node, err = service.DefaultNode.FindBySharedNodeID(ctx, r.NodeID); err != nil {
+		return nil, err
+	}
+
+	f := types.ExposedModuleFilter{
+		NodeID:   node.ID,
+		LastSync: r.LastSync,
+	}
+
+	if f.Paging, err = filter.NewPaging(r.Limit, r.PageCursor); err != nil {
+		return nil, err
+	}
+
+	if f.Sorting, err = filter.NewSorting(r.Sort); err != nil {
+		return nil, err
+	}
+
+	list, f, err := (service.ExposedModule()).Find(ctx, f)
+
+	if err != nil {
+		return nil, err
+	}
+
+	return &federation.ListStructurePayload{
+		NodeID: node.ID,
+		Filter: &f,
+		Set:    &list,
+	}, nil
+}