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

server/system/rest/handlers/actionlog.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/pkg/api"
+	"github.com/cortezaproject/corteza/server/system/rest/request"
+	"github.com/go-chi/chi/v5"
+	"net/http"
+)
+
+type (
+	// Internal API interface
+	ActionlogAPI interface {
+		List(context.Context, *request.ActionlogList) (interface{}, error)
+	}
+
+	// HTTP API interface
+	Actionlog struct {
+		List func(http.ResponseWriter, *http.Request)
+	}
+)
+
+func NewActionlog(h ActionlogAPI) *Actionlog {
+	return &Actionlog{
+		List: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewActionlogList()
+			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)
+		},
+	}
+}
+
+func (h Actionlog) MountRoutes(r chi.Router, middlewares ...func(http.Handler) http.Handler) {
+	r.Group(func(r chi.Router) {
+		r.Use(middlewares...)
+		r.Get("/actionlog/", h.List)
+	})
+}

server/system/rest/handlers/apigwFilter.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/pkg/api"
+	"github.com/cortezaproject/corteza/server/system/rest/request"
+	"github.com/go-chi/chi/v5"
+	"net/http"
+)
+
+type (
+	// Internal API interface
+	ApigwFilterAPI interface {
+		List(context.Context, *request.ApigwFilterList) (interface{}, error)
+		Create(context.Context, *request.ApigwFilterCreate) (interface{}, error)
+		Update(context.Context, *request.ApigwFilterUpdate) (interface{}, error)
+		Read(context.Context, *request.ApigwFilterRead) (interface{}, error)
+		Delete(context.Context, *request.ApigwFilterDelete) (interface{}, error)
+		Undelete(context.Context, *request.ApigwFilterUndelete) (interface{}, error)
+		DefFilter(context.Context, *request.ApigwFilterDefFilter) (interface{}, error)
+		DefProxyAuth(context.Context, *request.ApigwFilterDefProxyAuth) (interface{}, error)
+	}
+
+	// HTTP API interface
+	ApigwFilter struct {
+		List         func(http.ResponseWriter, *http.Request)
+		Create       func(http.ResponseWriter, *http.Request)
+		Update       func(http.ResponseWriter, *http.Request)
+		Read         func(http.ResponseWriter, *http.Request)
+		Delete       func(http.ResponseWriter, *http.Request)
+		Undelete     func(http.ResponseWriter, *http.Request)
+		DefFilter    func(http.ResponseWriter, *http.Request)
+		DefProxyAuth func(http.ResponseWriter, *http.Request)
+	}
+)
+
+func NewApigwFilter(h ApigwFilterAPI) *ApigwFilter {
+	return &ApigwFilter{
+		List: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewApigwFilterList()
+			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)
+		},
+		Create: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewApigwFilterCreate()
+			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)
+		},
+		Update: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewApigwFilterUpdate()
+			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)
+		},
+		Read: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewApigwFilterRead()
+			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.NewApigwFilterDelete()
+			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.NewApigwFilterUndelete()
+			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)
+		},
+		DefFilter: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewApigwFilterDefFilter()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.DefFilter(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		DefProxyAuth: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewApigwFilterDefProxyAuth()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.DefProxyAuth(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+	}
+}
+
+func (h ApigwFilter) MountRoutes(r chi.Router, middlewares ...func(http.Handler) http.Handler) {
+	r.Group(func(r chi.Router) {
+		r.Use(middlewares...)
+		r.Get("/apigw/filter/", h.List)
+		r.Put("/apigw/filter", h.Create)
+		r.Post("/apigw/filter/{filterID}", h.Update)
+		r.Get("/apigw/filter/{filterID}", h.Read)
+		r.Delete("/apigw/filter/{filterID}", h.Delete)
+		r.Post("/apigw/filter/{filterID}/undelete", h.Undelete)
+		r.Get("/apigw/filter/def", h.DefFilter)
+		r.Get("/apigw/filter/proxy_auth/def", h.DefProxyAuth)
+	})
+}

server/system/rest/handlers/apigwProfiler.go

@@ -0,0 +1,133 @@
+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/pkg/api"
+	"github.com/cortezaproject/corteza/server/system/rest/request"
+	"github.com/go-chi/chi/v5"
+	"net/http"
+)
+
+type (
+	// Internal API interface
+	ApigwProfilerAPI interface {
+		Aggregation(context.Context, *request.ApigwProfilerAggregation) (interface{}, error)
+		Route(context.Context, *request.ApigwProfilerRoute) (interface{}, error)
+		Hit(context.Context, *request.ApigwProfilerHit) (interface{}, error)
+		PurgeAll(context.Context, *request.ApigwProfilerPurgeAll) (interface{}, error)
+		Purge(context.Context, *request.ApigwProfilerPurge) (interface{}, error)
+	}
+
+	// HTTP API interface
+	ApigwProfiler struct {
+		Aggregation func(http.ResponseWriter, *http.Request)
+		Route       func(http.ResponseWriter, *http.Request)
+		Hit         func(http.ResponseWriter, *http.Request)
+		PurgeAll    func(http.ResponseWriter, *http.Request)
+		Purge       func(http.ResponseWriter, *http.Request)
+	}
+)
+
+func NewApigwProfiler(h ApigwProfilerAPI) *ApigwProfiler {
+	return &ApigwProfiler{
+		Aggregation: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewApigwProfilerAggregation()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Aggregation(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Route: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewApigwProfilerRoute()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Route(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Hit: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewApigwProfilerHit()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Hit(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		PurgeAll: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewApigwProfilerPurgeAll()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.PurgeAll(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Purge: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewApigwProfilerPurge()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Purge(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+	}
+}
+
+func (h ApigwProfiler) MountRoutes(r chi.Router, middlewares ...func(http.Handler) http.Handler) {
+	r.Group(func(r chi.Router) {
+		r.Use(middlewares...)
+		r.Get("/apigw/profiler/", h.Aggregation)
+		r.Get("/apigw/profiler/route/{routeID}", h.Route)
+		r.Get("/apigw/profiler/hit/{hitID}", h.Hit)
+		r.Post("/apigw/profiler/purge", h.PurgeAll)
+		r.Post("/apigw/profiler/purge/{routeID}", h.Purge)
+	})
+}

server/system/rest/handlers/apigwRoute.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/pkg/api"
+	"github.com/cortezaproject/corteza/server/system/rest/request"
+	"github.com/go-chi/chi/v5"
+	"net/http"
+)
+
+type (
+	// Internal API interface
+	ApigwRouteAPI interface {
+		List(context.Context, *request.ApigwRouteList) (interface{}, error)
+		Create(context.Context, *request.ApigwRouteCreate) (interface{}, error)
+		Update(context.Context, *request.ApigwRouteUpdate) (interface{}, error)
+		Read(context.Context, *request.ApigwRouteRead) (interface{}, error)
+		Delete(context.Context, *request.ApigwRouteDelete) (interface{}, error)
+		Undelete(context.Context, *request.ApigwRouteUndelete) (interface{}, error)
+	}
+
+	// HTTP API interface
+	ApigwRoute struct {
+		List     func(http.ResponseWriter, *http.Request)
+		Create   func(http.ResponseWriter, *http.Request)
+		Update   func(http.ResponseWriter, *http.Request)
+		Read     func(http.ResponseWriter, *http.Request)
+		Delete   func(http.ResponseWriter, *http.Request)
+		Undelete func(http.ResponseWriter, *http.Request)
+	}
+)
+
+func NewApigwRoute(h ApigwRouteAPI) *ApigwRoute {
+	return &ApigwRoute{
+		List: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewApigwRouteList()
+			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)
+		},
+		Create: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewApigwRouteCreate()
+			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)
+		},
+		Update: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewApigwRouteUpdate()
+			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)
+		},
+		Read: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewApigwRouteRead()
+			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.NewApigwRouteDelete()
+			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.NewApigwRouteUndelete()
+			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)
+		},
+	}
+}
+
+func (h ApigwRoute) MountRoutes(r chi.Router, middlewares ...func(http.Handler) http.Handler) {
+	r.Group(func(r chi.Router) {
+		r.Use(middlewares...)
+		r.Get("/apigw/route/", h.List)
+		r.Post("/apigw/route", h.Create)
+		r.Put("/apigw/route/{routeID}", h.Update)
+		r.Get("/apigw/route/{routeID}", h.Read)
+		r.Delete("/apigw/route/{routeID}", h.Delete)
+		r.Post("/apigw/route/{routeID}/undelete", h.Undelete)
+	})
+}

server/system/rest/handlers/application.go

@@ -0,0 +1,247 @@
+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/pkg/api"
+	"github.com/cortezaproject/corteza/server/system/rest/request"
+	"github.com/go-chi/chi/v5"
+	"net/http"
+)
+
+type (
+	// Internal API interface
+	ApplicationAPI interface {
+		List(context.Context, *request.ApplicationList) (interface{}, error)
+		Create(context.Context, *request.ApplicationCreate) (interface{}, error)
+		Update(context.Context, *request.ApplicationUpdate) (interface{}, error)
+		Upload(context.Context, *request.ApplicationUpload) (interface{}, error)
+		FlagCreate(context.Context, *request.ApplicationFlagCreate) (interface{}, error)
+		FlagDelete(context.Context, *request.ApplicationFlagDelete) (interface{}, error)
+		Read(context.Context, *request.ApplicationRead) (interface{}, error)
+		Delete(context.Context, *request.ApplicationDelete) (interface{}, error)
+		Undelete(context.Context, *request.ApplicationUndelete) (interface{}, error)
+		TriggerScript(context.Context, *request.ApplicationTriggerScript) (interface{}, error)
+		Reorder(context.Context, *request.ApplicationReorder) (interface{}, error)
+	}
+
+	// HTTP API interface
+	Application struct {
+		List          func(http.ResponseWriter, *http.Request)
+		Create        func(http.ResponseWriter, *http.Request)
+		Update        func(http.ResponseWriter, *http.Request)
+		Upload        func(http.ResponseWriter, *http.Request)
+		FlagCreate    func(http.ResponseWriter, *http.Request)
+		FlagDelete    func(http.ResponseWriter, *http.Request)
+		Read          func(http.ResponseWriter, *http.Request)
+		Delete        func(http.ResponseWriter, *http.Request)
+		Undelete      func(http.ResponseWriter, *http.Request)
+		TriggerScript func(http.ResponseWriter, *http.Request)
+		Reorder       func(http.ResponseWriter, *http.Request)
+	}
+)
+
+func NewApplication(h ApplicationAPI) *Application {
+	return &Application{
+		List: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewApplicationList()
+			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)
+		},
+		Create: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewApplicationCreate()
+			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)
+		},
+		Update: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewApplicationUpdate()
+			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)
+		},
+		Upload: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewApplicationUpload()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Upload(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		FlagCreate: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewApplicationFlagCreate()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.FlagCreate(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		FlagDelete: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewApplicationFlagDelete()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.FlagDelete(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.NewApplicationRead()
+			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.NewApplicationDelete()
+			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.NewApplicationUndelete()
+			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)
+		},
+		TriggerScript: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewApplicationTriggerScript()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.TriggerScript(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Reorder: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewApplicationReorder()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Reorder(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+	}
+}
+
+func (h Application) MountRoutes(r chi.Router, middlewares ...func(http.Handler) http.Handler) {
+	r.Group(func(r chi.Router) {
+		r.Use(middlewares...)
+		r.Get("/application/", h.List)
+		r.Post("/application/", h.Create)
+		r.Put("/application/{applicationID}", h.Update)
+		r.Post("/application/upload", h.Upload)
+		r.Post("/application/{applicationID}/flag/{ownedBy}/{flag}", h.FlagCreate)
+		r.Delete("/application/{applicationID}/flag/{ownedBy}/{flag}", h.FlagDelete)
+		r.Get("/application/{applicationID}", h.Read)
+		r.Delete("/application/{applicationID}", h.Delete)
+		r.Post("/application/{applicationID}/undelete", h.Undelete)
+		r.Post("/application/{applicationID}/trigger", h.TriggerScript)
+		r.Post("/application/reorder", h.Reorder)
+	})
+}

server/system/rest/handlers/attachment.go

@@ -0,0 +1,114 @@
+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/pkg/api"
+	"github.com/cortezaproject/corteza/server/system/rest/request"
+	"github.com/go-chi/chi/v5"
+	"net/http"
+)
+
+type (
+	// Internal API interface
+	AttachmentAPI interface {
+		Read(context.Context, *request.AttachmentRead) (interface{}, error)
+		Delete(context.Context, *request.AttachmentDelete) (interface{}, error)
+		Original(context.Context, *request.AttachmentOriginal) (interface{}, error)
+		Preview(context.Context, *request.AttachmentPreview) (interface{}, error)
+	}
+
+	// HTTP API interface
+	Attachment struct {
+		Read     func(http.ResponseWriter, *http.Request)
+		Delete   func(http.ResponseWriter, *http.Request)
+		Original func(http.ResponseWriter, *http.Request)
+		Preview  func(http.ResponseWriter, *http.Request)
+	}
+)
+
+func NewAttachment(h AttachmentAPI) *Attachment {
+	return &Attachment{
+		Read: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewAttachmentRead()
+			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.NewAttachmentDelete()
+			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)
+		},
+		Original: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewAttachmentOriginal()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Original(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Preview: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewAttachmentPreview()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Preview(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+	}
+}
+
+func (h Attachment) MountRoutes(r chi.Router, middlewares ...func(http.Handler) http.Handler) {
+	r.Group(func(r chi.Router) {
+		r.Use(middlewares...)
+		r.Get("/attachment/{kind}/{attachmentID}", h.Read)
+		r.Delete("/attachment/{kind}/{attachmentID}", h.Delete)
+		r.Get("/attachment/{kind}/{attachmentID}/original/{name}", h.Original)
+		r.Get("/attachment/{kind}/{attachmentID}/preview.{ext}", h.Preview)
+	})
+}

server/system/rest/handlers/auth.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/pkg/api"
+	"github.com/cortezaproject/corteza/server/system/rest/request"
+	"github.com/go-chi/chi/v5"
+	"net/http"
+)
+
+type (
+	// Internal API interface
+	AuthAPI interface {
+		Impersonate(context.Context, *request.AuthImpersonate) (interface{}, error)
+	}
+
+	// HTTP API interface
+	Auth struct {
+		Impersonate func(http.ResponseWriter, *http.Request)
+	}
+)
+
+func NewAuth(h AuthAPI) *Auth {
+	return &Auth{
+		Impersonate: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewAuthImpersonate()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Impersonate(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+	}
+}
+
+func (h Auth) MountRoutes(r chi.Router, middlewares ...func(http.Handler) http.Handler) {
+	r.Group(func(r chi.Router) {
+		r.Use(middlewares...)
+		r.Post("/auth/impersonate", h.Impersonate)
+	})
+}

server/system/rest/handlers/authClient.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/pkg/api"
+	"github.com/cortezaproject/corteza/server/system/rest/request"
+	"github.com/go-chi/chi/v5"
+	"net/http"
+)
+
+type (
+	// Internal API interface
+	AuthClientAPI interface {
+		List(context.Context, *request.AuthClientList) (interface{}, error)
+		Create(context.Context, *request.AuthClientCreate) (interface{}, error)
+		Update(context.Context, *request.AuthClientUpdate) (interface{}, error)
+		Read(context.Context, *request.AuthClientRead) (interface{}, error)
+		Delete(context.Context, *request.AuthClientDelete) (interface{}, error)
+		Undelete(context.Context, *request.AuthClientUndelete) (interface{}, error)
+		RegenerateSecret(context.Context, *request.AuthClientRegenerateSecret) (interface{}, error)
+		ExposeSecret(context.Context, *request.AuthClientExposeSecret) (interface{}, error)
+	}
+
+	// HTTP API interface
+	AuthClient struct {
+		List             func(http.ResponseWriter, *http.Request)
+		Create           func(http.ResponseWriter, *http.Request)
+		Update           func(http.ResponseWriter, *http.Request)
+		Read             func(http.ResponseWriter, *http.Request)
+		Delete           func(http.ResponseWriter, *http.Request)
+		Undelete         func(http.ResponseWriter, *http.Request)
+		RegenerateSecret func(http.ResponseWriter, *http.Request)
+		ExposeSecret     func(http.ResponseWriter, *http.Request)
+	}
+)
+
+func NewAuthClient(h AuthClientAPI) *AuthClient {
+	return &AuthClient{
+		List: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewAuthClientList()
+			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)
+		},
+		Create: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewAuthClientCreate()
+			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)
+		},
+		Update: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewAuthClientUpdate()
+			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)
+		},
+		Read: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewAuthClientRead()
+			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.NewAuthClientDelete()
+			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.NewAuthClientUndelete()
+			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)
+		},
+		RegenerateSecret: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewAuthClientRegenerateSecret()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.RegenerateSecret(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		ExposeSecret: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewAuthClientExposeSecret()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.ExposeSecret(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+	}
+}
+
+func (h AuthClient) MountRoutes(r chi.Router, middlewares ...func(http.Handler) http.Handler) {
+	r.Group(func(r chi.Router) {
+		r.Use(middlewares...)
+		r.Get("/auth/clients/", h.List)
+		r.Post("/auth/clients/", h.Create)
+		r.Put("/auth/clients/{clientID}", h.Update)
+		r.Get("/auth/clients/{clientID}", h.Read)
+		r.Delete("/auth/clients/{clientID}", h.Delete)
+		r.Post("/auth/clients/{clientID}/undelete", h.Undelete)
+		r.Post("/auth/clients/{clientID}/secret", h.RegenerateSecret)
+		r.Get("/auth/clients/{clientID}/secret", h.ExposeSecret)
+	})
+}

server/system/rest/handlers/automation.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/pkg/api"
+	"github.com/cortezaproject/corteza/server/system/rest/request"
+	"github.com/go-chi/chi/v5"
+	"net/http"
+)
+
+type (
+	// Internal API interface
+	AutomationAPI interface {
+		List(context.Context, *request.AutomationList) (interface{}, error)
+		Bundle(context.Context, *request.AutomationBundle) (interface{}, error)
+		TriggerScript(context.Context, *request.AutomationTriggerScript) (interface{}, error)
+	}
+
+	// HTTP API interface
+	Automation struct {
+		List          func(http.ResponseWriter, *http.Request)
+		Bundle        func(http.ResponseWriter, *http.Request)
+		TriggerScript func(http.ResponseWriter, *http.Request)
+	}
+)
+
+func NewAutomation(h AutomationAPI) *Automation {
+	return &Automation{
+		List: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewAutomationList()
+			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)
+		},
+		Bundle: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewAutomationBundle()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Bundle(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		TriggerScript: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewAutomationTriggerScript()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.TriggerScript(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+	}
+}
+
+func (h Automation) MountRoutes(r chi.Router, middlewares ...func(http.Handler) http.Handler) {
+	r.Group(func(r chi.Router) {
+		r.Use(middlewares...)
+		r.Get("/automation/", h.List)
+		r.Get("/automation/{bundle}-{type}.{ext}", h.Bundle)
+		r.Post("/automation/trigger", h.TriggerScript)
+	})
+}

server/system/rest/handlers/dalConnection.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/pkg/api"
+	"github.com/cortezaproject/corteza/server/system/rest/request"
+	"github.com/go-chi/chi/v5"
+	"net/http"
+)
+
+type (
+	// Internal API interface
+	DalConnectionAPI interface {
+		List(context.Context, *request.DalConnectionList) (interface{}, error)
+		Create(context.Context, *request.DalConnectionCreate) (interface{}, error)
+		Update(context.Context, *request.DalConnectionUpdate) (interface{}, error)
+		Read(context.Context, *request.DalConnectionRead) (interface{}, error)
+		Delete(context.Context, *request.DalConnectionDelete) (interface{}, error)
+		Undelete(context.Context, *request.DalConnectionUndelete) (interface{}, error)
+	}
+
+	// HTTP API interface
+	DalConnection struct {
+		List     func(http.ResponseWriter, *http.Request)
+		Create   func(http.ResponseWriter, *http.Request)
+		Update   func(http.ResponseWriter, *http.Request)
+		Read     func(http.ResponseWriter, *http.Request)
+		Delete   func(http.ResponseWriter, *http.Request)
+		Undelete func(http.ResponseWriter, *http.Request)
+	}
+)
+
+func NewDalConnection(h DalConnectionAPI) *DalConnection {
+	return &DalConnection{
+		List: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewDalConnectionList()
+			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)
+		},
+		Create: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewDalConnectionCreate()
+			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)
+		},
+		Update: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewDalConnectionUpdate()
+			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)
+		},
+		Read: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewDalConnectionRead()
+			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.NewDalConnectionDelete()
+			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.NewDalConnectionUndelete()
+			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)
+		},
+	}
+}
+
+func (h DalConnection) MountRoutes(r chi.Router, middlewares ...func(http.Handler) http.Handler) {
+	r.Group(func(r chi.Router) {
+		r.Use(middlewares...)
+		r.Get("/dal/connections/", h.List)
+		r.Post("/dal/connections/", h.Create)
+		r.Put("/dal/connections/{connectionID}", h.Update)
+		r.Get("/dal/connections/{connectionID}", h.Read)
+		r.Delete("/dal/connections/{connectionID}", h.Delete)
+		r.Post("/dal/connections/{connectionID}/undelete", h.Undelete)
+	})
+}

server/system/rest/handlers/dalDriver.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/pkg/api"
+	"github.com/cortezaproject/corteza/server/system/rest/request"
+	"github.com/go-chi/chi/v5"
+	"net/http"
+)
+
+type (
+	// Internal API interface
+	DalDriverAPI interface {
+		List(context.Context, *request.DalDriverList) (interface{}, error)
+	}
+
+	// HTTP API interface
+	DalDriver struct {
+		List func(http.ResponseWriter, *http.Request)
+	}
+)
+
+func NewDalDriver(h DalDriverAPI) *DalDriver {
+	return &DalDriver{
+		List: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewDalDriverList()
+			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)
+		},
+	}
+}
+
+func (h DalDriver) MountRoutes(r chi.Router, middlewares ...func(http.Handler) http.Handler) {
+	r.Group(func(r chi.Router) {
+		r.Use(middlewares...)
+		r.Get("/dal/drivers/", h.List)
+	})
+}

server/system/rest/handlers/dalSchemaAlteration.go

@@ -0,0 +1,114 @@
+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/pkg/api"
+	"github.com/cortezaproject/corteza/server/system/rest/request"
+	"github.com/go-chi/chi/v5"
+	"net/http"
+)
+
+type (
+	// Internal API interface
+	DalSchemaAlterationAPI interface {
+		List(context.Context, *request.DalSchemaAlterationList) (interface{}, error)
+		Read(context.Context, *request.DalSchemaAlterationRead) (interface{}, error)
+		Apply(context.Context, *request.DalSchemaAlterationApply) (interface{}, error)
+		Dismiss(context.Context, *request.DalSchemaAlterationDismiss) (interface{}, error)
+	}
+
+	// HTTP API interface
+	DalSchemaAlteration struct {
+		List    func(http.ResponseWriter, *http.Request)
+		Read    func(http.ResponseWriter, *http.Request)
+		Apply   func(http.ResponseWriter, *http.Request)
+		Dismiss func(http.ResponseWriter, *http.Request)
+	}
+)
+
+func NewDalSchemaAlteration(h DalSchemaAlterationAPI) *DalSchemaAlteration {
+	return &DalSchemaAlteration{
+		List: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewDalSchemaAlterationList()
+			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)
+		},
+		Read: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewDalSchemaAlterationRead()
+			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)
+		},
+		Apply: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewDalSchemaAlterationApply()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Apply(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Dismiss: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewDalSchemaAlterationDismiss()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Dismiss(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+	}
+}
+
+func (h DalSchemaAlteration) MountRoutes(r chi.Router, middlewares ...func(http.Handler) http.Handler) {
+	r.Group(func(r chi.Router) {
+		r.Use(middlewares...)
+		r.Get("/dal/schema/alterations/", h.List)
+		r.Get("/dal/schema/alterations/{alterationID}", h.Read)
+		r.Post("/dal/schema/alterations/apply", h.Apply)
+		r.Post("/dal/schema/alterations/dismiss", h.Dismiss)
+	})
+}

server/system/rest/handlers/dalSensitivityLevel.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/pkg/api"
+	"github.com/cortezaproject/corteza/server/system/rest/request"
+	"github.com/go-chi/chi/v5"
+	"net/http"
+)
+
+type (
+	// Internal API interface
+	DalSensitivityLevelAPI interface {
+		List(context.Context, *request.DalSensitivityLevelList) (interface{}, error)
+		Create(context.Context, *request.DalSensitivityLevelCreate) (interface{}, error)
+		Update(context.Context, *request.DalSensitivityLevelUpdate) (interface{}, error)
+		Read(context.Context, *request.DalSensitivityLevelRead) (interface{}, error)
+		Delete(context.Context, *request.DalSensitivityLevelDelete) (interface{}, error)
+		Undelete(context.Context, *request.DalSensitivityLevelUndelete) (interface{}, error)
+	}
+
+	// HTTP API interface
+	DalSensitivityLevel struct {
+		List     func(http.ResponseWriter, *http.Request)
+		Create   func(http.ResponseWriter, *http.Request)
+		Update   func(http.ResponseWriter, *http.Request)
+		Read     func(http.ResponseWriter, *http.Request)
+		Delete   func(http.ResponseWriter, *http.Request)
+		Undelete func(http.ResponseWriter, *http.Request)
+	}
+)
+
+func NewDalSensitivityLevel(h DalSensitivityLevelAPI) *DalSensitivityLevel {
+	return &DalSensitivityLevel{
+		List: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewDalSensitivityLevelList()
+			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)
+		},
+		Create: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewDalSensitivityLevelCreate()
+			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)
+		},
+		Update: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewDalSensitivityLevelUpdate()
+			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)
+		},
+		Read: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewDalSensitivityLevelRead()
+			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.NewDalSensitivityLevelDelete()
+			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.NewDalSensitivityLevelUndelete()
+			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)
+		},
+	}
+}
+
+func (h DalSensitivityLevel) MountRoutes(r chi.Router, middlewares ...func(http.Handler) http.Handler) {
+	r.Group(func(r chi.Router) {
+		r.Use(middlewares...)
+		r.Get("/dal/sensitivity-levels/", h.List)
+		r.Post("/dal/sensitivity-levels/", h.Create)
+		r.Put("/dal/sensitivity-levels/{sensitivityLevelID}", h.Update)
+		r.Get("/dal/sensitivity-levels/{sensitivityLevelID}", h.Read)
+		r.Delete("/dal/sensitivity-levels/{sensitivityLevelID}", h.Delete)
+		r.Post("/dal/sensitivity-levels/{sensitivityLevelID}/undelete", h.Undelete)
+	})
+}

server/system/rest/handlers/dataPrivacy.go

@@ -0,0 +1,171 @@
+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/pkg/api"
+	"github.com/cortezaproject/corteza/server/system/rest/request"
+	"github.com/go-chi/chi/v5"
+	"net/http"
+)
+
+type (
+	// Internal API interface
+	DataPrivacyAPI interface {
+		ConnectionList(context.Context, *request.DataPrivacyConnectionList) (interface{}, error)
+		RequestList(context.Context, *request.DataPrivacyRequestList) (interface{}, error)
+		RequestCreate(context.Context, *request.DataPrivacyRequestCreate) (interface{}, error)
+		RequestRead(context.Context, *request.DataPrivacyRequestRead) (interface{}, error)
+		RequestUpdateStatus(context.Context, *request.DataPrivacyRequestUpdateStatus) (interface{}, error)
+		RequestCommentList(context.Context, *request.DataPrivacyRequestCommentList) (interface{}, error)
+		RequestCommentCreate(context.Context, *request.DataPrivacyRequestCommentCreate) (interface{}, error)
+	}
+
+	// HTTP API interface
+	DataPrivacy struct {
+		ConnectionList       func(http.ResponseWriter, *http.Request)
+		RequestList          func(http.ResponseWriter, *http.Request)
+		RequestCreate        func(http.ResponseWriter, *http.Request)
+		RequestRead          func(http.ResponseWriter, *http.Request)
+		RequestUpdateStatus  func(http.ResponseWriter, *http.Request)
+		RequestCommentList   func(http.ResponseWriter, *http.Request)
+		RequestCommentCreate func(http.ResponseWriter, *http.Request)
+	}
+)
+
+func NewDataPrivacy(h DataPrivacyAPI) *DataPrivacy {
+	return &DataPrivacy{
+		ConnectionList: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewDataPrivacyConnectionList()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.ConnectionList(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		RequestList: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewDataPrivacyRequestList()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.RequestList(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		RequestCreate: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewDataPrivacyRequestCreate()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.RequestCreate(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		RequestRead: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewDataPrivacyRequestRead()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.RequestRead(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		RequestUpdateStatus: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewDataPrivacyRequestUpdateStatus()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.RequestUpdateStatus(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		RequestCommentList: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewDataPrivacyRequestCommentList()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.RequestCommentList(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		RequestCommentCreate: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewDataPrivacyRequestCommentCreate()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.RequestCommentCreate(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+	}
+}
+
+func (h DataPrivacy) MountRoutes(r chi.Router, middlewares ...func(http.Handler) http.Handler) {
+	r.Group(func(r chi.Router) {
+		r.Use(middlewares...)
+		r.Get("/data-privacy/connection/", h.ConnectionList)
+		r.Get("/data-privacy/requests/", h.RequestList)
+		r.Post("/data-privacy/requests/", h.RequestCreate)
+		r.Get("/data-privacy/requests/{requestID}", h.RequestRead)
+		r.Patch("/data-privacy/requests/{requestID}/status/{status}", h.RequestUpdateStatus)
+		r.Get("/data-privacy/requests/{requestID}/comments/", h.RequestCommentList)
+		r.Post("/data-privacy/requests/{requestID}/comments/", h.RequestCommentCreate)
+	})
+}

server/system/rest/handlers/expression.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/pkg/api"
+	"github.com/cortezaproject/corteza/server/system/rest/request"
+	"github.com/go-chi/chi/v5"
+	"net/http"
+)
+
+type (
+	// Internal API interface
+	ExpressionAPI interface {
+		Evaluate(context.Context, *request.ExpressionEvaluate) (interface{}, error)
+	}
+
+	// HTTP API interface
+	Expression struct {
+		Evaluate func(http.ResponseWriter, *http.Request)
+	}
+)
+
+func NewExpression(h ExpressionAPI) *Expression {
+	return &Expression{
+		Evaluate: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewExpressionEvaluate()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Evaluate(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+	}
+}
+
+func (h Expression) MountRoutes(r chi.Router, middlewares ...func(http.Handler) http.Handler) {
+	r.Group(func(r chi.Router) {
+		r.Use(middlewares...)
+		r.Post("/expressions/evaluate", h.Evaluate)
+	})
+}

server/system/rest/handlers/label.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/pkg/api"
+	"github.com/cortezaproject/corteza/server/system/rest/request"
+	"github.com/go-chi/chi/v5"
+	"net/http"
+)
+
+type (
+	// Internal API interface
+	LabelAPI interface {
+		List(context.Context, *request.LabelList) (interface{}, error)
+	}
+
+	// HTTP API interface
+	Label struct {
+		List func(http.ResponseWriter, *http.Request)
+	}
+)
+
+func NewLabel(h LabelAPI) *Label {
+	return &Label{
+		List: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewLabelList()
+			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)
+		},
+	}
+}
+
+func (h Label) MountRoutes(r chi.Router, middlewares ...func(http.Handler) http.Handler) {
+	r.Group(func(r chi.Router) {
+		r.Use(middlewares...)
+		r.Get("/label/", h.List)
+	})
+}

server/system/rest/handlers/locale.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/pkg/api"
+	"github.com/cortezaproject/corteza/server/system/rest/request"
+	"github.com/go-chi/chi/v5"
+	"net/http"
+)
+
+type (
+	// Internal API interface
+	LocaleAPI interface {
+		ListResource(context.Context, *request.LocaleListResource) (interface{}, error)
+		CreateResource(context.Context, *request.LocaleCreateResource) (interface{}, error)
+		UpdateResource(context.Context, *request.LocaleUpdateResource) (interface{}, error)
+		ReadResource(context.Context, *request.LocaleReadResource) (interface{}, error)
+		DeleteResource(context.Context, *request.LocaleDeleteResource) (interface{}, error)
+		UndeleteResource(context.Context, *request.LocaleUndeleteResource) (interface{}, error)
+		List(context.Context, *request.LocaleList) (interface{}, error)
+		Get(context.Context, *request.LocaleGet) (interface{}, error)
+	}
+
+	// HTTP API interface
+	Locale struct {
+		ListResource     func(http.ResponseWriter, *http.Request)
+		CreateResource   func(http.ResponseWriter, *http.Request)
+		UpdateResource   func(http.ResponseWriter, *http.Request)
+		ReadResource     func(http.ResponseWriter, *http.Request)
+		DeleteResource   func(http.ResponseWriter, *http.Request)
+		UndeleteResource func(http.ResponseWriter, *http.Request)
+		List             func(http.ResponseWriter, *http.Request)
+		Get              func(http.ResponseWriter, *http.Request)
+	}
+)
+
+func NewLocale(h LocaleAPI) *Locale {
+	return &Locale{
+		ListResource: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewLocaleListResource()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.ListResource(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		CreateResource: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewLocaleCreateResource()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.CreateResource(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		UpdateResource: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewLocaleUpdateResource()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.UpdateResource(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		ReadResource: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewLocaleReadResource()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.ReadResource(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		DeleteResource: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewLocaleDeleteResource()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.DeleteResource(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		UndeleteResource: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewLocaleUndeleteResource()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.UndeleteResource(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		List: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewLocaleList()
+			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)
+		},
+		Get: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewLocaleGet()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Get(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+	}
+}
+
+func (h Locale) MountRoutes(r chi.Router, middlewares ...func(http.Handler) http.Handler) {
+	r.Group(func(r chi.Router) {
+		r.Use(middlewares...)
+		r.Get("/locale/resource", h.ListResource)
+		r.Post("/locale/resource", h.CreateResource)
+		r.Put("/locale/resource/{translationID}", h.UpdateResource)
+		r.Get("/locale/resource/{translationID}", h.ReadResource)
+		r.Delete("/locale/resource/{translationID}", h.DeleteResource)
+		r.Post("/locale/resource/{translationID}/undelete", h.UndeleteResource)
+		r.Get("/locale/", h.List)
+		r.Get("/locale/{lang}/{application}", h.Get)
+	})
+}

server/system/rest/handlers/notification.go

@@ -0,0 +1,209 @@
+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/pkg/api"
+	"github.com/cortezaproject/corteza/server/system/rest/request"
+	"github.com/go-chi/chi/v5"
+	"net/http"
+)
+
+type (
+	// Internal API interface
+	NotificationAPI interface {
+		List(context.Context, *request.NotificationList) (interface{}, error)
+		Create(context.Context, *request.NotificationCreate) (interface{}, error)
+		Update(context.Context, *request.NotificationUpdate) (interface{}, error)
+		Read(context.Context, *request.NotificationRead) (interface{}, error)
+		Delete(context.Context, *request.NotificationDelete) (interface{}, error)
+		MarkAsRead(context.Context, *request.NotificationMarkAsRead) (interface{}, error)
+		MarkAsUnread(context.Context, *request.NotificationMarkAsUnread) (interface{}, error)
+		MarkAllAsRead(context.Context, *request.NotificationMarkAllAsRead) (interface{}, error)
+		MarkAllAsUnread(context.Context, *request.NotificationMarkAllAsUnread) (interface{}, error)
+	}
+
+	// HTTP API interface
+	Notification struct {
+		List            func(http.ResponseWriter, *http.Request)
+		Create          func(http.ResponseWriter, *http.Request)
+		Update          func(http.ResponseWriter, *http.Request)
+		Read            func(http.ResponseWriter, *http.Request)
+		Delete          func(http.ResponseWriter, *http.Request)
+		MarkAsRead      func(http.ResponseWriter, *http.Request)
+		MarkAsUnread    func(http.ResponseWriter, *http.Request)
+		MarkAllAsRead   func(http.ResponseWriter, *http.Request)
+		MarkAllAsUnread func(http.ResponseWriter, *http.Request)
+	}
+)
+
+func NewNotification(h NotificationAPI) *Notification {
+	return &Notification{
+		List: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewNotificationList()
+			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)
+		},
+		Create: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewNotificationCreate()
+			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)
+		},
+		Update: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewNotificationUpdate()
+			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)
+		},
+		Read: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewNotificationRead()
+			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.NewNotificationDelete()
+			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)
+		},
+		MarkAsRead: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewNotificationMarkAsRead()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.MarkAsRead(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		MarkAsUnread: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewNotificationMarkAsUnread()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.MarkAsUnread(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		MarkAllAsRead: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewNotificationMarkAllAsRead()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.MarkAllAsRead(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		MarkAllAsUnread: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewNotificationMarkAllAsUnread()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.MarkAllAsUnread(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+	}
+}
+
+func (h Notification) MountRoutes(r chi.Router, middlewares ...func(http.Handler) http.Handler) {
+	r.Group(func(r chi.Router) {
+		r.Use(middlewares...)
+		r.Get("/notification/", h.List)
+		r.Post("/notification/", h.Create)
+		r.Put("/notification/{notificationID}", h.Update)
+		r.Get("/notification/{notificationID}", h.Read)
+		r.Delete("/notification/{notificationID}", h.Delete)
+		r.Patch("/notification/{notificationID}/read", h.MarkAsRead)
+		r.Patch("/notification/{notificationID}/unread", h.MarkAsUnread)
+		r.Patch("/notification/all/read", h.MarkAllAsRead)
+		r.Patch("/notification/all/unread", h.MarkAllAsUnread)
+	})
+}

server/system/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/pkg/api"
+	"github.com/cortezaproject/corteza/server/system/rest/request"
+	"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/system/rest/handlers/queues.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/pkg/api"
+	"github.com/cortezaproject/corteza/server/system/rest/request"
+	"github.com/go-chi/chi/v5"
+	"net/http"
+)
+
+type (
+	// Internal API interface
+	QueuesAPI interface {
+		List(context.Context, *request.QueuesList) (interface{}, error)
+		Create(context.Context, *request.QueuesCreate) (interface{}, error)
+		Read(context.Context, *request.QueuesRead) (interface{}, error)
+		Update(context.Context, *request.QueuesUpdate) (interface{}, error)
+		Delete(context.Context, *request.QueuesDelete) (interface{}, error)
+		Undelete(context.Context, *request.QueuesUndelete) (interface{}, error)
+	}
+
+	// HTTP API interface
+	Queues struct {
+		List     func(http.ResponseWriter, *http.Request)
+		Create   func(http.ResponseWriter, *http.Request)
+		Read     func(http.ResponseWriter, *http.Request)
+		Update   func(http.ResponseWriter, *http.Request)
+		Delete   func(http.ResponseWriter, *http.Request)
+		Undelete func(http.ResponseWriter, *http.Request)
+	}
+)
+
+func NewQueues(h QueuesAPI) *Queues {
+	return &Queues{
+		List: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewQueuesList()
+			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)
+		},
+		Create: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewQueuesCreate()
+			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.NewQueuesRead()
+			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)
+		},
+		Update: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewQueuesUpdate()
+			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.NewQueuesDelete()
+			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.NewQueuesUndelete()
+			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)
+		},
+	}
+}
+
+func (h Queues) MountRoutes(r chi.Router, middlewares ...func(http.Handler) http.Handler) {
+	r.Group(func(r chi.Router) {
+		r.Use(middlewares...)
+		r.Get("/queues/", h.List)
+		r.Post("/queues", h.Create)
+		r.Get("/queues/{queueID}", h.Read)
+		r.Put("/queues/{queueID}", h.Update)
+		r.Delete("/queues/{queueID}", h.Delete)
+		r.Post("/queues/{queueID}/undelete", h.Undelete)
+	})
+}

server/system/rest/handlers/reminder.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/pkg/api"
+	"github.com/cortezaproject/corteza/server/system/rest/request"
+	"github.com/go-chi/chi/v5"
+	"net/http"
+)
+
+type (
+	// Internal API interface
+	ReminderAPI interface {
+		List(context.Context, *request.ReminderList) (interface{}, error)
+		Create(context.Context, *request.ReminderCreate) (interface{}, error)
+		Update(context.Context, *request.ReminderUpdate) (interface{}, error)
+		Read(context.Context, *request.ReminderRead) (interface{}, error)
+		Delete(context.Context, *request.ReminderDelete) (interface{}, error)
+		Dismiss(context.Context, *request.ReminderDismiss) (interface{}, error)
+		Undismiss(context.Context, *request.ReminderUndismiss) (interface{}, error)
+		Snooze(context.Context, *request.ReminderSnooze) (interface{}, error)
+	}
+
+	// HTTP API interface
+	Reminder struct {
+		List      func(http.ResponseWriter, *http.Request)
+		Create    func(http.ResponseWriter, *http.Request)
+		Update    func(http.ResponseWriter, *http.Request)
+		Read      func(http.ResponseWriter, *http.Request)
+		Delete    func(http.ResponseWriter, *http.Request)
+		Dismiss   func(http.ResponseWriter, *http.Request)
+		Undismiss func(http.ResponseWriter, *http.Request)
+		Snooze    func(http.ResponseWriter, *http.Request)
+	}
+)
+
+func NewReminder(h ReminderAPI) *Reminder {
+	return &Reminder{
+		List: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewReminderList()
+			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)
+		},
+		Create: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewReminderCreate()
+			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)
+		},
+		Update: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewReminderUpdate()
+			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)
+		},
+		Read: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewReminderRead()
+			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.NewReminderDelete()
+			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)
+		},
+		Dismiss: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewReminderDismiss()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Dismiss(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Undismiss: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewReminderUndismiss()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Undismiss(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Snooze: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewReminderSnooze()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Snooze(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+	}
+}
+
+func (h Reminder) MountRoutes(r chi.Router, middlewares ...func(http.Handler) http.Handler) {
+	r.Group(func(r chi.Router) {
+		r.Use(middlewares...)
+		r.Get("/reminder/", h.List)
+		r.Post("/reminder/", h.Create)
+		r.Put("/reminder/{reminderID}", h.Update)
+		r.Get("/reminder/{reminderID}", h.Read)
+		r.Delete("/reminder/{reminderID}", h.Delete)
+		r.Patch("/reminder/{reminderID}/dismiss", h.Dismiss)
+		r.Patch("/reminder/{reminderID}/undismiss", h.Undismiss)
+		r.Patch("/reminder/{reminderID}/snooze", h.Snooze)
+	})
+}

server/system/rest/handlers/report.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/pkg/api"
+	"github.com/cortezaproject/corteza/server/system/rest/request"
+	"github.com/go-chi/chi/v5"
+	"net/http"
+)
+
+type (
+	// Internal API interface
+	ReportAPI interface {
+		List(context.Context, *request.ReportList) (interface{}, error)
+		Create(context.Context, *request.ReportCreate) (interface{}, error)
+		Update(context.Context, *request.ReportUpdate) (interface{}, error)
+		Read(context.Context, *request.ReportRead) (interface{}, error)
+		Delete(context.Context, *request.ReportDelete) (interface{}, error)
+		Undelete(context.Context, *request.ReportUndelete) (interface{}, error)
+		Describe(context.Context, *request.ReportDescribe) (interface{}, error)
+		Run(context.Context, *request.ReportRun) (interface{}, error)
+	}
+
+	// HTTP API interface
+	Report struct {
+		List     func(http.ResponseWriter, *http.Request)
+		Create   func(http.ResponseWriter, *http.Request)
+		Update   func(http.ResponseWriter, *http.Request)
+		Read     func(http.ResponseWriter, *http.Request)
+		Delete   func(http.ResponseWriter, *http.Request)
+		Undelete func(http.ResponseWriter, *http.Request)
+		Describe func(http.ResponseWriter, *http.Request)
+		Run      func(http.ResponseWriter, *http.Request)
+	}
+)
+
+func NewReport(h ReportAPI) *Report {
+	return &Report{
+		List: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewReportList()
+			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)
+		},
+		Create: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewReportCreate()
+			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)
+		},
+		Update: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewReportUpdate()
+			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)
+		},
+		Read: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewReportRead()
+			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.NewReportDelete()
+			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.NewReportUndelete()
+			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)
+		},
+		Describe: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewReportDescribe()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Describe(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Run: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewReportRun()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Run(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+	}
+}
+
+func (h Report) MountRoutes(r chi.Router, middlewares ...func(http.Handler) http.Handler) {
+	r.Group(func(r chi.Router) {
+		r.Use(middlewares...)
+		r.Get("/reports/", h.List)
+		r.Post("/reports/", h.Create)
+		r.Put("/reports/{reportID}", h.Update)
+		r.Get("/reports/{reportID}", h.Read)
+		r.Delete("/reports/{reportID}", h.Delete)
+		r.Post("/reports/{reportID}/undelete", h.Undelete)
+		r.Post("/reports/describe", h.Describe)
+		r.Post("/reports/{reportID}/run", h.Run)
+	})
+}

server/system/rest/handlers/role.go

@@ -0,0 +1,361 @@
+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/pkg/api"
+	"github.com/cortezaproject/corteza/server/system/rest/request"
+	"github.com/go-chi/chi/v5"
+	"net/http"
+)
+
+type (
+	// Internal API interface
+	RoleAPI interface {
+		List(context.Context, *request.RoleList) (interface{}, error)
+		Create(context.Context, *request.RoleCreate) (interface{}, error)
+		Update(context.Context, *request.RoleUpdate) (interface{}, error)
+		Read(context.Context, *request.RoleRead) (interface{}, error)
+		Delete(context.Context, *request.RoleDelete) (interface{}, error)
+		Archive(context.Context, *request.RoleArchive) (interface{}, error)
+		Unarchive(context.Context, *request.RoleUnarchive) (interface{}, error)
+		Undelete(context.Context, *request.RoleUndelete) (interface{}, error)
+		Move(context.Context, *request.RoleMove) (interface{}, error)
+		Merge(context.Context, *request.RoleMerge) (interface{}, error)
+		MemberList(context.Context, *request.RoleMemberList) (interface{}, error)
+		MemberAddGroup(context.Context, *request.RoleMemberAddGroup) (interface{}, error)
+		MemberAdd(context.Context, *request.RoleMemberAdd) (interface{}, error)
+		MemberRemove(context.Context, *request.RoleMemberRemove) (interface{}, error)
+		MemberRemoveGroup(context.Context, *request.RoleMemberRemoveGroup) (interface{}, error)
+		TriggerScript(context.Context, *request.RoleTriggerScript) (interface{}, error)
+		CloneRules(context.Context, *request.RoleCloneRules) (interface{}, error)
+	}
+
+	// HTTP API interface
+	Role struct {
+		List              func(http.ResponseWriter, *http.Request)
+		Create            func(http.ResponseWriter, *http.Request)
+		Update            func(http.ResponseWriter, *http.Request)
+		Read              func(http.ResponseWriter, *http.Request)
+		Delete            func(http.ResponseWriter, *http.Request)
+		Archive           func(http.ResponseWriter, *http.Request)
+		Unarchive         func(http.ResponseWriter, *http.Request)
+		Undelete          func(http.ResponseWriter, *http.Request)
+		Move              func(http.ResponseWriter, *http.Request)
+		Merge             func(http.ResponseWriter, *http.Request)
+		MemberList        func(http.ResponseWriter, *http.Request)
+		MemberAddGroup    func(http.ResponseWriter, *http.Request)
+		MemberAdd         func(http.ResponseWriter, *http.Request)
+		MemberRemove      func(http.ResponseWriter, *http.Request)
+		MemberRemoveGroup func(http.ResponseWriter, *http.Request)
+		TriggerScript     func(http.ResponseWriter, *http.Request)
+		CloneRules        func(http.ResponseWriter, *http.Request)
+	}
+)
+
+func NewRole(h RoleAPI) *Role {
+	return &Role{
+		List: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewRoleList()
+			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)
+		},
+		Create: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewRoleCreate()
+			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)
+		},
+		Update: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewRoleUpdate()
+			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)
+		},
+		Read: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewRoleRead()
+			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.NewRoleDelete()
+			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)
+		},
+		Archive: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewRoleArchive()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Archive(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Unarchive: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewRoleUnarchive()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Unarchive(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.NewRoleUndelete()
+			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)
+		},
+		Move: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewRoleMove()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Move(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Merge: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewRoleMerge()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Merge(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		MemberList: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewRoleMemberList()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.MemberList(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		MemberAddGroup: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewRoleMemberAddGroup()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.MemberAddGroup(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		MemberAdd: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewRoleMemberAdd()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.MemberAdd(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		MemberRemove: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewRoleMemberRemove()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.MemberRemove(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		MemberRemoveGroup: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewRoleMemberRemoveGroup()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.MemberRemoveGroup(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		TriggerScript: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewRoleTriggerScript()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.TriggerScript(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		CloneRules: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewRoleCloneRules()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.CloneRules(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+	}
+}
+
+func (h Role) MountRoutes(r chi.Router, middlewares ...func(http.Handler) http.Handler) {
+	r.Group(func(r chi.Router) {
+		r.Use(middlewares...)
+		r.Get("/roles/", h.List)
+		r.Post("/roles/", h.Create)
+		r.Put("/roles/{roleID}", h.Update)
+		r.Get("/roles/{roleID}", h.Read)
+		r.Delete("/roles/{roleID}", h.Delete)
+		r.Post("/roles/{roleID}/archive", h.Archive)
+		r.Post("/roles/{roleID}/unarchive", h.Unarchive)
+		r.Post("/roles/{roleID}/undelete", h.Undelete)
+		r.Post("/roles/{roleID}/move", h.Move)
+		r.Post("/roles/{roleID}/merge", h.Merge)
+		r.Get("/roles/{roleID}/members", h.MemberList)
+		r.Post("/roles/{roleID}/member-g/{userGroupID}", h.MemberAddGroup)
+		r.Post("/roles/{roleID}/member/{userID}", h.MemberAdd)
+		r.Delete("/roles/{roleID}/member/{userID}", h.MemberRemove)
+		r.Delete("/roles/{roleID}/member-g/{userGroupID}", h.MemberRemoveGroup)
+		r.Post("/roles/{roleID}/trigger", h.TriggerScript)
+		r.Post("/roles/{roleID}/rules/clone", h.CloneRules)
+	})
+}

server/system/rest/handlers/settings.go

@@ -0,0 +1,133 @@
+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/pkg/api"
+	"github.com/cortezaproject/corteza/server/system/rest/request"
+	"github.com/go-chi/chi/v5"
+	"net/http"
+)
+
+type (
+	// Internal API interface
+	SettingsAPI interface {
+		List(context.Context, *request.SettingsList) (interface{}, error)
+		Update(context.Context, *request.SettingsUpdate) (interface{}, error)
+		Get(context.Context, *request.SettingsGet) (interface{}, error)
+		Set(context.Context, *request.SettingsSet) (interface{}, error)
+		Current(context.Context, *request.SettingsCurrent) (interface{}, error)
+	}
+
+	// HTTP API interface
+	Settings struct {
+		List    func(http.ResponseWriter, *http.Request)
+		Update  func(http.ResponseWriter, *http.Request)
+		Get     func(http.ResponseWriter, *http.Request)
+		Set     func(http.ResponseWriter, *http.Request)
+		Current func(http.ResponseWriter, *http.Request)
+	}
+)
+
+func NewSettings(h SettingsAPI) *Settings {
+	return &Settings{
+		List: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewSettingsList()
+			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)
+		},
+		Update: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewSettingsUpdate()
+			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)
+		},
+		Get: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewSettingsGet()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Get(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Set: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewSettingsSet()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Set(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Current: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewSettingsCurrent()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Current(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+	}
+}
+
+func (h Settings) MountRoutes(r chi.Router, middlewares ...func(http.Handler) http.Handler) {
+	r.Group(func(r chi.Router) {
+		r.Use(middlewares...)
+		r.Get("/settings/", h.List)
+		r.Patch("/settings/", h.Update)
+		r.Get("/settings/{key}", h.Get)
+		r.Post("/settings/{key}", h.Set)
+		r.Get("/settings/current", h.Current)
+	})
+}

server/system/rest/handlers/smtpConfigurationChecker.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/pkg/api"
+	"github.com/cortezaproject/corteza/server/system/rest/request"
+	"github.com/go-chi/chi/v5"
+	"net/http"
+)
+
+type (
+	// Internal API interface
+	SmtpConfigurationCheckerAPI interface {
+		Check(context.Context, *request.SmtpConfigurationCheckerCheck) (interface{}, error)
+	}
+
+	// HTTP API interface
+	SmtpConfigurationChecker struct {
+		Check func(http.ResponseWriter, *http.Request)
+	}
+)
+
+func NewSmtpConfigurationChecker(h SmtpConfigurationCheckerAPI) *SmtpConfigurationChecker {
+	return &SmtpConfigurationChecker{
+		Check: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewSmtpConfigurationCheckerCheck()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Check(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+	}
+}
+
+func (h SmtpConfigurationChecker) MountRoutes(r chi.Router, middlewares ...func(http.Handler) http.Handler) {
+	r.Group(func(r chi.Router) {
+		r.Use(middlewares...)
+		r.Post("/smtp/configuration-checker/", h.Check)
+	})
+}

server/system/rest/handlers/stats.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/pkg/api"
+	"github.com/cortezaproject/corteza/server/system/rest/request"
+	"github.com/go-chi/chi/v5"
+	"net/http"
+)
+
+type (
+	// Internal API interface
+	StatsAPI interface {
+		List(context.Context, *request.StatsList) (interface{}, error)
+	}
+
+	// HTTP API interface
+	Stats struct {
+		List func(http.ResponseWriter, *http.Request)
+	}
+)
+
+func NewStats(h StatsAPI) *Stats {
+	return &Stats{
+		List: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewStatsList()
+			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)
+		},
+	}
+}
+
+func (h Stats) MountRoutes(r chi.Router, middlewares ...func(http.Handler) http.Handler) {
+	r.Group(func(r chi.Router) {
+		r.Use(middlewares...)
+		r.Get("/stats/", h.List)
+	})
+}

server/system/rest/handlers/template.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/pkg/api"
+	"github.com/cortezaproject/corteza/server/system/rest/request"
+	"github.com/go-chi/chi/v5"
+	"net/http"
+)
+
+type (
+	// Internal API interface
+	TemplateAPI interface {
+		List(context.Context, *request.TemplateList) (interface{}, error)
+		Create(context.Context, *request.TemplateCreate) (interface{}, error)
+		Read(context.Context, *request.TemplateRead) (interface{}, error)
+		Update(context.Context, *request.TemplateUpdate) (interface{}, error)
+		Delete(context.Context, *request.TemplateDelete) (interface{}, error)
+		Undelete(context.Context, *request.TemplateUndelete) (interface{}, error)
+		RenderDrivers(context.Context, *request.TemplateRenderDrivers) (interface{}, error)
+		Render(context.Context, *request.TemplateRender) (interface{}, error)
+	}
+
+	// HTTP API interface
+	Template struct {
+		List          func(http.ResponseWriter, *http.Request)
+		Create        func(http.ResponseWriter, *http.Request)
+		Read          func(http.ResponseWriter, *http.Request)
+		Update        func(http.ResponseWriter, *http.Request)
+		Delete        func(http.ResponseWriter, *http.Request)
+		Undelete      func(http.ResponseWriter, *http.Request)
+		RenderDrivers func(http.ResponseWriter, *http.Request)
+		Render        func(http.ResponseWriter, *http.Request)
+	}
+)
+
+func NewTemplate(h TemplateAPI) *Template {
+	return &Template{
+		List: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewTemplateList()
+			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)
+		},
+		Create: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewTemplateCreate()
+			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.NewTemplateRead()
+			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)
+		},
+		Update: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewTemplateUpdate()
+			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.NewTemplateDelete()
+			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.NewTemplateUndelete()
+			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)
+		},
+		RenderDrivers: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewTemplateRenderDrivers()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.RenderDrivers(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Render: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewTemplateRender()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Render(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+	}
+}
+
+func (h Template) MountRoutes(r chi.Router, middlewares ...func(http.Handler) http.Handler) {
+	r.Group(func(r chi.Router) {
+		r.Use(middlewares...)
+		r.Get("/template/", h.List)
+		r.Post("/template/", h.Create)
+		r.Get("/template/{templateID}", h.Read)
+		r.Put("/template/{templateID}", h.Update)
+		r.Delete("/template/{templateID}", h.Delete)
+		r.Post("/template/{templateID}/undelete", h.Undelete)
+		r.Get("/template/render/drivers", h.RenderDrivers)
+		r.Post("/template/{templateID}/render/{filename}.{ext}", h.Render)
+	})
+}

server/system/rest/handlers/user.go

@@ -0,0 +1,456 @@
+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/pkg/api"
+	"github.com/cortezaproject/corteza/server/system/rest/request"
+	"github.com/go-chi/chi/v5"
+	"net/http"
+)
+
+type (
+	// Internal API interface
+	UserAPI interface {
+		List(context.Context, *request.UserList) (interface{}, error)
+		Create(context.Context, *request.UserCreate) (interface{}, error)
+		Update(context.Context, *request.UserUpdate) (interface{}, error)
+		PartialUpdate(context.Context, *request.UserPartialUpdate) (interface{}, error)
+		Read(context.Context, *request.UserRead) (interface{}, error)
+		Delete(context.Context, *request.UserDelete) (interface{}, error)
+		Suspend(context.Context, *request.UserSuspend) (interface{}, error)
+		Unsuspend(context.Context, *request.UserUnsuspend) (interface{}, error)
+		Undelete(context.Context, *request.UserUndelete) (interface{}, error)
+		SetPassword(context.Context, *request.UserSetPassword) (interface{}, error)
+		MembershipList(context.Context, *request.UserMembershipList) (interface{}, error)
+		MembershipAdd(context.Context, *request.UserMembershipAdd) (interface{}, error)
+		MembershipRemove(context.Context, *request.UserMembershipRemove) (interface{}, error)
+		TriggerScript(context.Context, *request.UserTriggerScript) (interface{}, error)
+		SessionsRemove(context.Context, *request.UserSessionsRemove) (interface{}, error)
+		ListCredentials(context.Context, *request.UserListCredentials) (interface{}, error)
+		DeleteCredentials(context.Context, *request.UserDeleteCredentials) (interface{}, error)
+		ProfileAvatar(context.Context, *request.UserProfileAvatar) (interface{}, error)
+		ProfileAvatarInitial(context.Context, *request.UserProfileAvatarInitial) (interface{}, error)
+		DeleteAvatar(context.Context, *request.UserDeleteAvatar) (interface{}, error)
+		Export(context.Context, *request.UserExport) (interface{}, error)
+		Import(context.Context, *request.UserImport) (interface{}, error)
+	}
+
+	// HTTP API interface
+	User struct {
+		List                 func(http.ResponseWriter, *http.Request)
+		Create               func(http.ResponseWriter, *http.Request)
+		Update               func(http.ResponseWriter, *http.Request)
+		PartialUpdate        func(http.ResponseWriter, *http.Request)
+		Read                 func(http.ResponseWriter, *http.Request)
+		Delete               func(http.ResponseWriter, *http.Request)
+		Suspend              func(http.ResponseWriter, *http.Request)
+		Unsuspend            func(http.ResponseWriter, *http.Request)
+		Undelete             func(http.ResponseWriter, *http.Request)
+		SetPassword          func(http.ResponseWriter, *http.Request)
+		MembershipList       func(http.ResponseWriter, *http.Request)
+		MembershipAdd        func(http.ResponseWriter, *http.Request)
+		MembershipRemove     func(http.ResponseWriter, *http.Request)
+		TriggerScript        func(http.ResponseWriter, *http.Request)
+		SessionsRemove       func(http.ResponseWriter, *http.Request)
+		ListCredentials      func(http.ResponseWriter, *http.Request)
+		DeleteCredentials    func(http.ResponseWriter, *http.Request)
+		ProfileAvatar        func(http.ResponseWriter, *http.Request)
+		ProfileAvatarInitial func(http.ResponseWriter, *http.Request)
+		DeleteAvatar         func(http.ResponseWriter, *http.Request)
+		Export               func(http.ResponseWriter, *http.Request)
+		Import               func(http.ResponseWriter, *http.Request)
+	}
+)
+
+func NewUser(h UserAPI) *User {
+	return &User{
+		List: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewUserList()
+			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)
+		},
+		Create: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewUserCreate()
+			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)
+		},
+		Update: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewUserUpdate()
+			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)
+		},
+		PartialUpdate: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewUserPartialUpdate()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.PartialUpdate(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.NewUserRead()
+			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.NewUserDelete()
+			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)
+		},
+		Suspend: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewUserSuspend()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Suspend(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Unsuspend: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewUserUnsuspend()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Unsuspend(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.NewUserUndelete()
+			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)
+		},
+		SetPassword: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewUserSetPassword()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.SetPassword(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		MembershipList: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewUserMembershipList()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.MembershipList(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		MembershipAdd: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewUserMembershipAdd()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.MembershipAdd(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		MembershipRemove: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewUserMembershipRemove()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.MembershipRemove(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		TriggerScript: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewUserTriggerScript()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.TriggerScript(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		SessionsRemove: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewUserSessionsRemove()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.SessionsRemove(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		ListCredentials: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewUserListCredentials()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.ListCredentials(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		DeleteCredentials: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewUserDeleteCredentials()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.DeleteCredentials(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		ProfileAvatar: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewUserProfileAvatar()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.ProfileAvatar(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		ProfileAvatarInitial: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewUserProfileAvatarInitial()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.ProfileAvatarInitial(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		DeleteAvatar: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewUserDeleteAvatar()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.DeleteAvatar(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Export: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewUserExport()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Export(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Import: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewUserImport()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Import(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+	}
+}
+
+func (h User) MountRoutes(r chi.Router, middlewares ...func(http.Handler) http.Handler) {
+	r.Group(func(r chi.Router) {
+		r.Use(middlewares...)
+		r.Get("/users/", h.List)
+		r.Post("/users/", h.Create)
+		r.Put("/users/{userID}", h.Update)
+		r.Patch("/users/{userID}", h.PartialUpdate)
+		r.Get("/users/{userID}", h.Read)
+		r.Delete("/users/{userID}", h.Delete)
+		r.Post("/users/{userID}/suspend", h.Suspend)
+		r.Post("/users/{userID}/unsuspend", h.Unsuspend)
+		r.Post("/users/{userID}/undelete", h.Undelete)
+		r.Post("/users/{userID}/password", h.SetPassword)
+		r.Get("/users/{userID}/membership", h.MembershipList)
+		r.Post("/users/{userID}/membership/{roleID}", h.MembershipAdd)
+		r.Delete("/users/{userID}/membership/{roleID}", h.MembershipRemove)
+		r.Post("/users/{userID}/trigger", h.TriggerScript)
+		r.Delete("/users/{userID}/sessions", h.SessionsRemove)
+		r.Get("/users/{userID}/credentials", h.ListCredentials)
+		r.Delete("/users/{userID}/credentials/{credentialsID}", h.DeleteCredentials)
+		r.Post("/users/{userID}/avatar", h.ProfileAvatar)
+		r.Post("/users/{userID}/avatar-initial", h.ProfileAvatarInitial)
+		r.Delete("/users/{userID}/avatar", h.DeleteAvatar)
+		r.Get("/users/export/{filename}.zip", h.Export)
+		r.Post("/users/import", h.Import)
+	})
+}

server/system/rest/handlers/userGroup.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/pkg/api"
+	"github.com/cortezaproject/corteza/server/system/rest/request"
+	"github.com/go-chi/chi/v5"
+	"net/http"
+)
+
+type (
+	// Internal API interface
+	UserGroupAPI interface {
+		List(context.Context, *request.UserGroupList) (interface{}, error)
+		Create(context.Context, *request.UserGroupCreate) (interface{}, error)
+		Update(context.Context, *request.UserGroupUpdate) (interface{}, error)
+		Read(context.Context, *request.UserGroupRead) (interface{}, error)
+		Delete(context.Context, *request.UserGroupDelete) (interface{}, error)
+		Undelete(context.Context, *request.UserGroupUndelete) (interface{}, error)
+		MemberList(context.Context, *request.UserGroupMemberList) (interface{}, error)
+		MemberAdd(context.Context, *request.UserGroupMemberAdd) (interface{}, error)
+	}
+
+	// HTTP API interface
+	UserGroup struct {
+		List       func(http.ResponseWriter, *http.Request)
+		Create     func(http.ResponseWriter, *http.Request)
+		Update     func(http.ResponseWriter, *http.Request)
+		Read       func(http.ResponseWriter, *http.Request)
+		Delete     func(http.ResponseWriter, *http.Request)
+		Undelete   func(http.ResponseWriter, *http.Request)
+		MemberList func(http.ResponseWriter, *http.Request)
+		MemberAdd  func(http.ResponseWriter, *http.Request)
+	}
+)
+
+func NewUserGroup(h UserGroupAPI) *UserGroup {
+	return &UserGroup{
+		List: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewUserGroupList()
+			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)
+		},
+		Create: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewUserGroupCreate()
+			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)
+		},
+		Update: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewUserGroupUpdate()
+			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)
+		},
+		Read: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewUserGroupRead()
+			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.NewUserGroupDelete()
+			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.NewUserGroupUndelete()
+			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)
+		},
+		MemberList: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewUserGroupMemberList()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.MemberList(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		MemberAdd: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewUserGroupMemberAdd()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.MemberAdd(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+	}
+}
+
+func (h UserGroup) MountRoutes(r chi.Router, middlewares ...func(http.Handler) http.Handler) {
+	r.Group(func(r chi.Router) {
+		r.Use(middlewares...)
+		r.Get("/user-groups/", h.List)
+		r.Post("/user-groups/", h.Create)
+		r.Put("/user-groups/{userGroupID}", h.Update)
+		r.Get("/user-groups/{userGroupID}", h.Read)
+		r.Delete("/user-groups/{userGroupID}", h.Delete)
+		r.Post("/user-groups/{userGroupID}/undelete", h.Undelete)
+		r.Get("/user-groups/{userGroupID}/members", h.MemberList)
+		r.Post("/user-groups/{userGroupID}/member/{userID}", h.MemberAdd)
+	})
+}