diff --git a/CHANGELOG.md b/CHANGELOG.md
index 009abe37a..34af0cac4 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -129,6 +129,8 @@
   * `svc_flex_cpu_low_threshold`
   * `svc_flex_cpu_high_threshold`
 
+* **breaking change:** key-value stores (cfg, sec, usr kinded objects) `change` action is no longer failing if the key does not exist. The key is added instead.
+
 ### commands
 
 * **breaking change:** "om node freeze" is now local only. Use "om cluster freeze" for the orchestrated freeze of all nodes. Same applies to "unfreeze" and its hidden alias "thaw".
diff --git a/core/naming/kind.go b/core/naming/kind.go
index a6c8274ab..638075ee4 100644
--- a/core/naming/kind.go
+++ b/core/naming/kind.go
@@ -46,6 +46,12 @@ var (
 		string(KindNscfg): nil,
 	}
 
+	KindKVStore = []Kind{
+		KindCfg,
+		KindSec,
+		KindUsr,
+	}
+
 	KindAll = []Kind{
 		KindSvc,
 		KindVol,
@@ -55,6 +61,7 @@ var (
 		KindCcfg,
 		KindNscfg,
 	}
+
 	KindStrings = []string{
 		string(KindSvc),
 		string(KindVol),
diff --git a/core/object/factory.go b/core/object/factory.go
index 0ccf4119d..696e16a34 100644
--- a/core/object/factory.go
+++ b/core/object/factory.go
@@ -9,6 +9,8 @@ import (
 	"github.com/opensvc/om3/util/plog"
 )
 
+var ErrWrongType = errors.New("wrong type provided for interface")
+
 // WithConfigFile sets a non-standard configuration location.
 func WithConfigFile(s string) funcopt.O {
 	return funcopt.F(func(t any) error {
@@ -87,8 +89,10 @@ func New(p naming.Path, opts ...funcopt.O) (any, error) {
 func NewCore(p naming.Path, opts ...funcopt.O) (Core, error) {
 	if o, err := New(p, opts...); err != nil {
 		return nil, err
+	} else if i, ok := o.(Core); ok {
+		return i, nil
 	} else {
-		return o.(Core), nil
+		return nil, ErrWrongType
 	}
 }
 
@@ -96,8 +100,10 @@ func NewCore(p naming.Path, opts ...funcopt.O) (Core, error) {
 func NewConfigurer(p naming.Path, opts ...funcopt.O) (Configurer, error) {
 	if o, err := New(p, opts...); err != nil {
 		return nil, err
+	} else if i, ok := o.(Configurer); ok {
+		return i, nil
 	} else {
-		return o.(Configurer), nil
+		return nil, ErrWrongType
 	}
 }
 
@@ -105,8 +111,10 @@ func NewConfigurer(p naming.Path, opts ...funcopt.O) (Configurer, error) {
 func NewActor(p naming.Path, opts ...funcopt.O) (Actor, error) {
 	if o, err := New(p, opts...); err != nil {
 		return nil, err
+	} else if i, ok := o.(Actor); ok {
+		return i, nil
 	} else {
-		return o.(Actor), nil
+		return nil, ErrWrongType
 	}
 }
 
@@ -114,7 +122,9 @@ func NewActor(p naming.Path, opts ...funcopt.O) (Actor, error) {
 func NewKeystore(p naming.Path, opts ...funcopt.O) (Keystore, error) {
 	if o, err := New(p, opts...); err != nil {
 		return nil, err
+	} else if i, ok := o.(Keystore); ok {
+		return i, nil
 	} else {
-		return o.(Keystore), nil
+		return nil, ErrWrongType
 	}
 }
diff --git a/core/object/keystore.go b/core/object/keystore.go
index 6dd69b8db..d3858fbe1 100644
--- a/core/object/keystore.go
+++ b/core/object/keystore.go
@@ -2,6 +2,7 @@ package object
 
 import (
 	"os"
+	"path/filepath"
 
 	"github.com/opensvc/om3/util/key"
 )
@@ -26,9 +27,7 @@ type (
 		Core
 		HasKey(name string) bool
 		AddKey(name string, b []byte) error
-		AddKeyFrom(name string, from string) error
 		ChangeKey(name string, b []byte) error
-		ChangeKeyFrom(name string, from string) error
 		DecodeKey(keyname string) ([]byte, error)
 		AllKeys() ([]string, error)
 		MatchingKeys(string) ([]string, error)
@@ -36,6 +35,10 @@ type (
 		EditKey(name string) error
 		InstallKey(name string) error
 		InstallKeyTo(string, string, *os.FileMode, *os.FileMode, string, string) error
+
+		TransactionAddKey(name string, b []byte) error
+		TransactionChangeKey(name string, b []byte) error
+		TransactionRemoveKey(name string) error
 	}
 
 	// SecureKeystore is implemented by encrypting Keystore object kinds (usr, sec).
@@ -73,3 +76,16 @@ func (t *keystore) temporaryKeyFile(name string) (f *os.File, err error) {
 func (t *keystore) postCommit() error {
 	return t.postInstall("")
 }
+
+func FileToKey(path, prefix string) (string, error) {
+	if path == "" {
+		return prefix, nil
+	}
+	path = filepath.Clean(path)
+	dirName := filepath.Dir(path)
+	relPath, err := filepath.Rel(dirName, path)
+	if prefix == "" {
+		return relPath, err
+	}
+	return filepath.Join(prefix, relPath), nil
+}
diff --git a/core/object/keystore_add.go b/core/object/keystore_add.go
index 3d526424f..57beb248b 100644
--- a/core/object/keystore_add.go
+++ b/core/object/keystore_add.go
@@ -1,128 +1,50 @@
 package object
 
 import (
-	"bufio"
-	"fmt"
-	"io"
-	"os"
+	"errors"
 
 	"github.com/opensvc/om3/core/keyop"
-	"github.com/opensvc/om3/util/file"
-	"github.com/opensvc/om3/util/uri"
 )
 
-// AddKey sets a new key and commits immediately
-func (t *keystore) AddKey(name string, b []byte) error {
-	if t.HasKey(name) {
-		return fmt.Errorf("key already exist: %s. use the change action", name)
-	}
-	if err := t.addKey(name, b); err != nil {
-		return err
-	}
-	return t.config.Commit()
-}
+var (
+	KeystoreErrExist    = errors.New("key already exists")
+	KeystoreErrKeyEmpty = errors.New("key is empty")
+	KeystoreErrNotExist = errors.New("key does not exist")
+)
 
-// ChangeKey changes the value of a existing key and commits immediately
-func (t *keystore) ChangeKey(name string, b []byte) error {
-	if !t.HasKey(name) {
-		return fmt.Errorf("key does not exist: %s. use the add action", name)
-	}
-	if err := t.addKey(name, b); err != nil {
-		return err
-	}
-	return t.config.Commit()
-}
-func (t *keystore) AddKeyFrom(name string, from string) error {
-	if name == "" {
-		return fmt.Errorf("key name can not be empty")
-	}
+// TransactionAddKey sets a new key
+func (t *keystore) TransactionAddKey(name string, b []byte) error {
 	if t.HasKey(name) {
-		return fmt.Errorf("key already exist: %s. use the change action", name)
-	}
-	if err := t.alterFrom(name, from); err != nil {
-		return err
+		return KeystoreErrExist
 	}
-	return t.config.Commit()
+	return t.addKey(name, b)
 }
 
-func (t *keystore) ChangeKeyFrom(name string, from string) error {
-	if name == "" {
-		return fmt.Errorf("key name can not be empty")
-	}
-	if !t.HasKey(name) {
-		return fmt.Errorf("key does not exist: %s. use the add action", name)
-	}
-	if err := t.alterFrom(name, from); err != nil {
+// AddKey sets a new key and commits immediately
+func (t *keystore) AddKey(name string, b []byte) error {
+	if err := t.TransactionAddKey(name, b); err != nil {
 		return err
 	}
 	return t.config.Commit()
 }
 
-func (t *keystore) alterFrom(name string, from string) error {
-	switch from {
-	case "":
-		return fmt.Errorf("empty value source")
-	case "-", "stdin", "/dev/stdin":
-		return t.fromStdin(name)
-	default:
-		u := uri.New(from)
-		if u.IsValid() {
-			return t.fromURI(name, u)
-		}
-		if v, err := file.ExistsAndRegular(from); err != nil {
-			return err
-		} else if v {
-			return t.fromRegular(name, from)
-		}
-		if v, err := file.ExistsAndDir(from); err != nil {
-			return err
-		} else if v {
-			return t.fromDir(name, from)
-		}
-		return fmt.Errorf("unexpected value source: %s", from)
-	}
-}
-
-func (t *keystore) fromStdin(name string) error {
-	stat, _ := os.Stdin.Stat()
-	if (stat.Mode() & os.ModeCharDevice) == 0 {
-		reader := bufio.NewReader(os.Stdin)
-		b, err := io.ReadAll(reader)
-		if err != nil {
-			return err
-		}
-		return t.addKey(name, b)
-	} else {
-		return fmt.Errorf("stdin must be a pipe")
-	}
-}
-
-func (t *keystore) fromRegular(name string, p string) error {
-	b, err := os.ReadFile(p)
-	if err != nil {
-		return err
-	}
+// TransactionChangeKey inserts or updates the value of a existing key
+func (t *keystore) TransactionChangeKey(name string, b []byte) error {
 	return t.addKey(name, b)
 }
 
-func (t *keystore) fromDir(name string, p string) error {
-	// TODO: walk and call fromRegular
-	return nil
-}
-
-func (t *keystore) fromURI(name string, u uri.T) error {
-	fName, err := u.Fetch()
-	if err != nil {
+// ChangeKey changes the value of a existing key and commits immediately
+func (t *keystore) ChangeKey(name string, b []byte) error {
+	if err := t.TransactionChangeKey(name, b); err != nil {
 		return err
 	}
-	defer os.Remove(fName)
-	return t.fromRegular(name, fName)
+	return t.config.Commit()
 }
 
 // Note: addKey does not commit, so it can be used multiple times efficiently.
 func (t *keystore) addKey(name string, b []byte) error {
 	if name == "" {
-		return fmt.Errorf("key name can not be empty")
+		return KeystoreErrKeyEmpty
 	}
 	if b == nil {
 		b = []byte{}
diff --git a/core/object/keystore_install.go b/core/object/keystore_install.go
index ef0f149a8..9a71861d9 100644
--- a/core/object/keystore_install.go
+++ b/core/object/keystore_install.go
@@ -239,7 +239,6 @@ func (t *keystore) writeKey(vk vKey, dst string, b []byte, mode *os.FileMode, us
 		}
 	}
 	t.log.Infof("install %s/%s in %s", t.path.Name, vk.Key, dst)
-	fmt.Printf("install %s/%s in %s\n", t.path.Name, vk.Key, dst)
 	perm := os.ModePerm
 	if mode != nil {
 		perm = *mode
diff --git a/core/object/keystore_remove.go b/core/object/keystore_remove.go
index 9f7107ccf..856bb1b9b 100644
--- a/core/object/keystore_remove.go
+++ b/core/object/keystore_remove.go
@@ -5,6 +5,12 @@ import (
 )
 
 // RemoveKey removes a keyword from object
+func (t *keystore) TransactionRemoveKey(keyname string) error {
+	k := key.New(dataSectionName, keyname)
+	return t.config.PrepareUnset(k)
+}
+
+// RemoveKey removes a keyword from object and commits immediately
 func (t *keystore) RemoveKey(keyname string) error {
 	k := key.New(dataSectionName, keyname)
 	return t.config.Unset(k)
diff --git a/core/omcmd/keystore_add.go b/core/omcmd/keystore_add.go
index 68dfb4895..3e627ba89 100644
--- a/core/omcmd/keystore_add.go
+++ b/core/omcmd/keystore_add.go
@@ -6,6 +6,7 @@ import (
 	"github.com/opensvc/om3/core/naming"
 	"github.com/opensvc/om3/core/object"
 	"github.com/opensvc/om3/core/objectaction"
+	"github.com/opensvc/om3/util/uri"
 )
 
 type (
@@ -31,12 +32,23 @@ func (t *CmdKeystoreAdd) Run(selector, kind string) error {
 			if err != nil {
 				return nil, err
 			}
-			switch {
-			case t.From != "":
-				return nil, store.AddKeyFrom(t.Key, t.From)
-			default:
+			if t.Value != "" {
 				return nil, store.AddKey(t.Key, []byte(t.Value))
 			}
+			m, err := uri.ReadAllFrom(t.From)
+			if err != nil {
+				return nil, err
+			}
+			for path, b := range m {
+				k, err := object.FileToKey(path, t.Key)
+				if err != nil {
+					return nil, err
+				}
+				if err := store.TransactionAddKey(k, b); err != nil {
+					return nil, err
+				}
+			}
+			return nil, store.Config().CommitInvalid()
 		}),
 	).Do()
 }
diff --git a/core/omcmd/keystore_change.go b/core/omcmd/keystore_change.go
index 84db2f7fe..c45911f4b 100644
--- a/core/omcmd/keystore_change.go
+++ b/core/omcmd/keystore_change.go
@@ -6,6 +6,7 @@ import (
 	"github.com/opensvc/om3/core/naming"
 	"github.com/opensvc/om3/core/object"
 	"github.com/opensvc/om3/core/objectaction"
+	"github.com/opensvc/om3/util/uri"
 )
 
 type (
@@ -30,13 +31,24 @@ func (t *CmdKeystoreChange) Run(selector, kind string) error {
 			if err != nil {
 				return nil, err
 			}
-			switch {
-			case t.From != "":
-				return nil, store.ChangeKeyFrom(t.Key, t.From)
-			default:
+			if t.Value != "" {
 				return nil, store.ChangeKey(t.Key, []byte(t.Value))
 			}
+			m, err := uri.ReadAllFrom(t.From)
+			if err != nil {
+				return nil, err
+			}
+			for path, b := range m {
+				k, err := object.FileToKey(path, t.Key)
+				if err != nil {
+					return nil, err
+				}
 
+				if err := store.TransactionChangeKey(k, b); err != nil {
+					return nil, err
+				}
+			}
+			return nil, store.Config().CommitInvalid()
 		}),
 	).Do()
 }
diff --git a/core/ox/all.go b/core/ox/all.go
index 6c51556cf..25accf377 100644
--- a/core/ox/all.go
+++ b/core/ox/all.go
@@ -34,6 +34,12 @@ func init() {
 		cmdObjectSet,
 		cmdObjectSync,
 		cmdObjectValidate,
+		newCmdKeystoreAdd(kind),
+		newCmdKeystoreChange(kind),
+		newCmdKeystoreDecode(kind),
+		newCmdKeystoreKeys(kind),
+		newCmdKeystoreInstall(kind),
+		newCmdKeystoreRemove(kind),
 		newCmdObjectAbort(kind),
 		newCmdObjectBoot(kind),
 		newCmdObjectClear(kind),
diff --git a/core/oxcmd/keystore_add.go b/core/oxcmd/keystore_add.go
index 1ea04b5fb..79ce65baf 100644
--- a/core/oxcmd/keystore_add.go
+++ b/core/oxcmd/keystore_add.go
@@ -1,7 +1,15 @@
 package oxcmd
 
 import (
-	"github.com/opensvc/om3/core/objectaction"
+	"context"
+	"fmt"
+	"net/http"
+	"slices"
+
+	"github.com/opensvc/om3/core/client"
+	"github.com/opensvc/om3/core/naming"
+	"github.com/opensvc/om3/core/objectselector"
+	"github.com/opensvc/om3/daemon/api"
 )
 
 type (
@@ -15,10 +23,53 @@ type (
 )
 
 func (t *CmdKeystoreAdd) Run(selector, kind string) error {
-	mergedSelector := mergeSelector(selector, t.ObjectSelector, kind, "")
-	return objectaction.New(
-		objectaction.WithColor(t.Color),
-		objectaction.WithOutput(t.Output),
-		objectaction.WithObjectSelector(mergedSelector),
-	).Do()
+	data, err := makeKVStorePatch(t.Key, t.Value, t.From, api.Add)
+	if err != nil {
+		return err
+	}
+
+	ctx := context.Background()
+	c, err := client.New(client.WithURL(t.Server))
+	if err != nil {
+		return err
+	}
+	paths, err := objectselector.New(
+		selector,
+		objectselector.WithClient(c),
+	).Expand()
+	if err != nil {
+		return err
+	}
+	for _, path := range paths {
+		if !slices.Contains(naming.KindKVStore, path.Kind) {
+			continue
+		}
+		if err := t.RunForPath(ctx, c, path, data); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (t *CmdKeystoreAdd) RunForPath(ctx context.Context, c *client.T, path naming.Path, data api.PatchObjectKVStoreJSONRequestBody) error {
+	response, err := c.PatchObjectKVStoreWithResponse(ctx, path.Namespace, path.Kind, path.Name, data)
+	if err != nil {
+		return err
+	}
+	switch {
+	case response.StatusCode() == http.StatusNoContent:
+		return nil
+	case response.StatusCode() == http.StatusConflict:
+		return fmt.Errorf("%s: key already exists. consider using the 'change' action", path)
+	case response.JSON400 != nil:
+		return fmt.Errorf("%s: %s", path, *response.JSON400)
+	case response.JSON401 != nil:
+		return fmt.Errorf("%s: %s", path, *response.JSON401)
+	case response.JSON403 != nil:
+		return fmt.Errorf("%s: %s", path, *response.JSON403)
+	case response.JSON500 != nil:
+		return fmt.Errorf("%s: %s", path, *response.JSON500)
+	default:
+		return fmt.Errorf("%s: unexpected response: %s", path, response.Status())
+	}
 }
diff --git a/core/oxcmd/keystore_change.go b/core/oxcmd/keystore_change.go
index 683e68bc7..b0c6dd680 100644
--- a/core/oxcmd/keystore_change.go
+++ b/core/oxcmd/keystore_change.go
@@ -1,23 +1,106 @@
 package oxcmd
 
 import (
-	"github.com/opensvc/om3/core/objectaction"
+	"context"
+	"fmt"
+	"net/http"
+	"slices"
+
+	"github.com/opensvc/om3/core/client"
+	"github.com/opensvc/om3/core/naming"
+	"github.com/opensvc/om3/core/object"
+	"github.com/opensvc/om3/core/objectselector"
+	"github.com/opensvc/om3/daemon/api"
+	"github.com/opensvc/om3/util/uri"
 )
 
 type (
 	CmdKeystoreChange struct {
 		OptsGlobal
+		OptsLock
 		Key   string
 		From  string
 		Value string
 	}
 )
 
+func makeKVStorePatch(key, value, from string, action api.PatchKVStoreEntryAction) (api.PatchObjectKVStoreJSONRequestBody, error) {
+	data := make(api.PatchObjectKVStoreJSONRequestBody, 0)
+
+	if value != "" {
+		data = append(data, api.PatchKVStoreEntry{
+			Key:    key,
+			String: &value,
+			Action: action,
+		})
+		return data, nil
+	}
+	m, err := uri.ReadAllFrom(from)
+	if err != nil {
+		return data, err
+	}
+	for path, b := range m {
+		k, err := object.FileToKey(path, key)
+		if err != nil {
+			return nil, err
+		}
+		data = append(data, api.PatchKVStoreEntry{
+			Key:    k,
+			Bytes:  &b,
+			Action: action,
+		})
+	}
+	return data, nil
+}
+
 func (t *CmdKeystoreChange) Run(selector, kind string) error {
-	mergedSelector := mergeSelector(selector, t.ObjectSelector, kind, "")
-	return objectaction.New(
-		objectaction.WithColor(t.Color),
-		objectaction.WithOutput(t.Output),
-		objectaction.WithObjectSelector(mergedSelector),
-	).Do()
+	data, err := makeKVStorePatch(t.Key, t.Value, t.From, api.Change)
+	if err != nil {
+		return err
+	}
+
+	ctx := context.Background()
+	c, err := client.New(client.WithURL(t.Server))
+	if err != nil {
+		return err
+	}
+	paths, err := objectselector.New(
+		selector,
+		objectselector.WithClient(c),
+	).Expand()
+	if err != nil {
+		return err
+	}
+	for _, path := range paths {
+		if !slices.Contains(naming.KindKVStore, path.Kind) {
+			continue
+		}
+		if err := t.RunForPath(ctx, c, path, data); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (t *CmdKeystoreChange) RunForPath(ctx context.Context, c *client.T, path naming.Path, data api.PatchObjectKVStoreJSONRequestBody) error {
+	response, err := c.PatchObjectKVStoreWithResponse(ctx, path.Namespace, path.Kind, path.Name, data)
+	if err != nil {
+		return err
+	}
+	switch {
+	case response.StatusCode() == http.StatusNoContent:
+		return nil
+	case response.StatusCode() == http.StatusNotFound:
+		return fmt.Errorf("%s: key does not exists. consider using the 'add' action", path)
+	case response.JSON400 != nil:
+		return fmt.Errorf("%s: %s", path, *response.JSON400)
+	case response.JSON401 != nil:
+		return fmt.Errorf("%s: %s", path, *response.JSON401)
+	case response.JSON403 != nil:
+		return fmt.Errorf("%s: %s", path, *response.JSON403)
+	case response.JSON500 != nil:
+		return fmt.Errorf("%s: %s", path, *response.JSON500)
+	default:
+		return fmt.Errorf("%s: unexpected response: %s", path, response.Status())
+	}
 }
diff --git a/core/oxcmd/keystore_decode.go b/core/oxcmd/keystore_decode.go
index 69b0aaef3..85f4319ec 100644
--- a/core/oxcmd/keystore_decode.go
+++ b/core/oxcmd/keystore_decode.go
@@ -1,7 +1,18 @@
 package oxcmd
 
 import (
-	"github.com/opensvc/om3/core/objectaction"
+	"bytes"
+	"context"
+	"fmt"
+	"io"
+	"net/http"
+	"os"
+	"slices"
+
+	"github.com/opensvc/om3/core/client"
+	"github.com/opensvc/om3/core/naming"
+	"github.com/opensvc/om3/core/objectselector"
+	"github.com/opensvc/om3/daemon/api"
 )
 
 type (
@@ -12,10 +23,50 @@ type (
 )
 
 func (t *CmdKeystoreDecode) Run(selector, kind string) error {
-	mergedSelector := mergeSelector(selector, t.ObjectSelector, kind, "")
-	return objectaction.New(
-		objectaction.WithColor(t.Color),
-		objectaction.WithOutput(t.Output),
-		objectaction.WithObjectSelector(mergedSelector),
-	).Do()
+	ctx := context.Background()
+	c, err := client.New(client.WithURL(t.Server))
+	if err != nil {
+		return err
+	}
+	paths, err := objectselector.New(
+		selector,
+		objectselector.WithClient(c),
+	).Expand()
+	if err != nil {
+		return err
+	}
+	for _, path := range paths {
+		if !slices.Contains(naming.KindKVStore, path.Kind) {
+			continue
+		}
+		if err := t.RunForPath(ctx, c, path); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (t *CmdKeystoreDecode) RunForPath(ctx context.Context, c *client.T, path naming.Path) error {
+	params := api.GetObjectKVStoreEntryParams{
+		Key: t.Key,
+	}
+	response, err := c.GetObjectKVStoreEntryWithResponse(ctx, path.Namespace, path.Kind, path.Name, &params)
+	if err != nil {
+		return err
+	}
+	switch response.StatusCode() {
+	case http.StatusOK:
+		_, err := io.Copy(os.Stdout, bytes.NewReader(response.Body))
+		return err
+	case http.StatusBadRequest:
+		return fmt.Errorf("%s: %s", path, *response.JSON400)
+	case http.StatusUnauthorized:
+		return fmt.Errorf("%s: %s", path, *response.JSON401)
+	case http.StatusForbidden:
+		return fmt.Errorf("%s: %s", path, *response.JSON403)
+	case http.StatusInternalServerError:
+		return fmt.Errorf("%s: %s", path, *response.JSON500)
+	default:
+		return fmt.Errorf("%s: unexpected response: %s", path, response.Status())
+	}
 }
diff --git a/core/oxcmd/keystore_keys.go b/core/oxcmd/keystore_keys.go
index dd05a6e0e..57ffffed0 100644
--- a/core/oxcmd/keystore_keys.go
+++ b/core/oxcmd/keystore_keys.go
@@ -1,7 +1,17 @@
 package oxcmd
 
 import (
-	"github.com/opensvc/om3/core/objectaction"
+	"context"
+	"fmt"
+	"net/http"
+	"slices"
+
+	"github.com/opensvc/om3/core/client"
+	"github.com/opensvc/om3/core/naming"
+	"github.com/opensvc/om3/core/objectselector"
+	"github.com/opensvc/om3/core/output"
+	"github.com/opensvc/om3/core/rawconfig"
+	"github.com/opensvc/om3/daemon/api"
 )
 
 type (
@@ -12,10 +22,59 @@ type (
 )
 
 func (t *CmdKeystoreKeys) Run(selector, kind string) error {
-	mergedSelector := mergeSelector(selector, t.ObjectSelector, kind, "")
-	return objectaction.New(
-		objectaction.WithColor(t.Color),
-		objectaction.WithOutput(t.Output),
-		objectaction.WithObjectSelector(mergedSelector),
-	).Do()
+	ctx := context.Background()
+	c, err := client.New(client.WithURL(t.Server))
+	if err != nil {
+		return err
+	}
+	paths, err := objectselector.New(
+		selector,
+		objectselector.WithClient(c),
+	).Expand()
+	if err != nil {
+		return err
+	}
+	result := api.KVStoreKeyList{
+		Kind:  "KVStoreKeyList",
+		Items: make(api.KVStoreKeyListItems, 0),
+	}
+	for _, path := range paths {
+		if !slices.Contains(naming.KindKVStore, path.Kind) {
+			continue
+		}
+		if moreKeys, err := t.RunForPath(ctx, c, path); err != nil {
+			return err
+		} else {
+			result.Items = append(result.Items, moreKeys...)
+		}
+	}
+	output.Renderer{
+		DefaultOutput: "tab=OBJECT:object,NODE:node,KEY:key,SIZE:size",
+		Output:        t.Output,
+		Color:         t.Color,
+		Data:          result,
+		Colorize:      rawconfig.Colorize,
+	}.Print()
+	return nil
+}
+
+func (t *CmdKeystoreKeys) RunForPath(ctx context.Context, c *client.T, path naming.Path) (api.KVStoreKeyListItems, error) {
+	response, err := c.GetObjectKVStoreKeysWithResponse(ctx, path.Namespace, path.Kind, path.Name)
+	if err != nil {
+		return nil, err
+	}
+	switch response.StatusCode() {
+	case http.StatusOK:
+		return response.JSON200.Items, nil
+	case http.StatusBadRequest:
+		return nil, fmt.Errorf("%s: %s", path, *response.JSON400)
+	case http.StatusUnauthorized:
+		return nil, fmt.Errorf("%s: %s", path, *response.JSON401)
+	case http.StatusForbidden:
+		return nil, fmt.Errorf("%s: %s", path, *response.JSON403)
+	case http.StatusInternalServerError:
+		return nil, fmt.Errorf("%s: %s", path, *response.JSON500)
+	default:
+		return nil, fmt.Errorf("%s: unexpected response: %s", path, response.Status())
+	}
 }
diff --git a/core/oxcmd/keystore_remove.go b/core/oxcmd/keystore_remove.go
index 0d7d892ed..d03bcc866 100644
--- a/core/oxcmd/keystore_remove.go
+++ b/core/oxcmd/keystore_remove.go
@@ -1,7 +1,15 @@
 package oxcmd
 
 import (
-	"github.com/opensvc/om3/core/objectaction"
+	"context"
+	"fmt"
+	"net/http"
+	"slices"
+
+	"github.com/opensvc/om3/core/client"
+	"github.com/opensvc/om3/core/naming"
+	"github.com/opensvc/om3/core/objectselector"
+	"github.com/opensvc/om3/daemon/api"
 )
 
 type (
@@ -12,10 +20,49 @@ type (
 )
 
 func (t *CmdKeystoreRemove) Run(selector, kind string) error {
-	mergedSelector := mergeSelector(selector, t.ObjectSelector, kind, "")
-	return objectaction.New(
-		objectaction.WithColor(t.Color),
-		objectaction.WithOutput(t.Output),
-		objectaction.WithObjectSelector(mergedSelector),
-	).Do()
+	ctx := context.Background()
+	c, err := client.New(client.WithURL(t.Server))
+	if err != nil {
+		return err
+	}
+	paths, err := objectselector.New(
+		selector,
+		objectselector.WithClient(c),
+	).Expand()
+	if err != nil {
+		return err
+	}
+	for _, path := range paths {
+		if !slices.Contains(naming.KindKVStore, path.Kind) {
+			continue
+		}
+		if err := t.RunForPath(ctx, c, path); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (t *CmdKeystoreRemove) RunForPath(ctx context.Context, c *client.T, path naming.Path) error {
+	params := api.DeleteObjectKVStoreEntryParams{
+		Key: t.Key,
+	}
+	response, err := c.DeleteObjectKVStoreEntryWithResponse(ctx, path.Namespace, path.Kind, path.Name, &params)
+	if err != nil {
+		return err
+	}
+	switch response.StatusCode() {
+	case http.StatusNoContent:
+		return nil
+	case http.StatusBadRequest:
+		return fmt.Errorf("%s: %s", path, *response.JSON400)
+	case http.StatusUnauthorized:
+		return fmt.Errorf("%s: %s", path, *response.JSON401)
+	case http.StatusForbidden:
+		return fmt.Errorf("%s: %s", path, *response.JSON403)
+	case http.StatusInternalServerError:
+		return fmt.Errorf("%s: %s", path, *response.JSON500)
+	default:
+		return fmt.Errorf("%s: unexpected response: %s", path, response.Status())
+	}
 }
diff --git a/core/xconfig/main.go b/core/xconfig/main.go
index 120a6f675..f122f0aca 100644
--- a/core/xconfig/main.go
+++ b/core/xconfig/main.go
@@ -524,30 +524,40 @@ func (t *T) DriverGroupSet(op keyop.T) error {
 
 func (t *T) set(op keyop.T) error {
 	setSet := func(op keyop.T) error {
-		current := t.file.Section(op.Key.Section).Key(op.Key.Option).Value()
-		if current == op.Value {
+		current := t.file.Section(op.Key.Section).Key(op.Key.Option)
+		if current == nil {
+			return fmt.Errorf("invalid key in %s", op)
+		}
+		if current.Value() == op.Value {
 			return nil
 		}
-		t.file.Section(op.Key.Section).Key(op.Key.Option).SetValue(op.Value)
+		current.SetValue(op.Value)
 		t.changed = true
 		return nil
 	}
 	setAppend := func(op keyop.T) error {
-		current := t.file.Section(op.Key.Section).Key(op.Key.Option).Value()
+		current := t.file.Section(op.Key.Section).Key(op.Key.Option)
+		if current == nil {
+			return fmt.Errorf("invalid key in %s", op)
+		}
 		target := ""
-		if current == "" {
+		if current.Value() == "" {
 			target = op.Value
 		} else {
-			target = fmt.Sprintf("%s %s", current, op.Value)
+			target = fmt.Sprintf("%s %s", current.Value(), op.Value)
 		}
-		t.file.Section(op.Key.Section).Key(op.Key.Option).SetValue(target)
+		current.SetValue(target)
 		t.changed = true
 		return nil
 	}
 	setMerge := func(op keyop.T) error {
-		current := strings.Fields(t.file.Section(op.Key.Section).Key(op.Key.Option).Value())
+		current := t.file.Section(op.Key.Section).Key(op.Key.Option)
+		if current == nil {
+			return fmt.Errorf("invalid key in %s", op)
+		}
+		currentFields := strings.Fields(current.Value())
 		currentSet := set.New()
-		for _, e := range current {
+		for _, e := range currentFields {
 			currentSet.Insert(e)
 		}
 		if currentSet.Has(op.Value) {
@@ -557,10 +567,14 @@ func (t *T) set(op keyop.T) error {
 	}
 
 	setRemove := func(op keyop.T) error {
-		current := strings.Fields(t.file.Section(op.Key.Section).Key(op.Key.Option).Value())
+		current := t.file.Section(op.Key.Section).Key(op.Key.Option)
+		if current == nil {
+			return fmt.Errorf("invalid key in %s", op)
+		}
+		currentFields := strings.Fields(current.Value())
 		target := []string{}
 		removed := 0
-		for _, e := range current {
+		for _, e := range currentFields {
 			if e == op.Value {
 				removed++
 				continue
@@ -570,15 +584,19 @@ func (t *T) set(op keyop.T) error {
 		if removed == 0 {
 			return nil
 		}
-		t.file.Section(op.Key.Section).Key(op.Key.Option).SetValue(strings.Join(target, " "))
+		current.SetValue(strings.Join(target, " "))
 		t.changed = true
 		return nil
 	}
 
 	setToggle := func(op keyop.T) error {
-		current := strings.Fields(t.file.Section(op.Key.Section).Key(op.Key.Option).Value())
+		current := t.file.Section(op.Key.Section).Key(op.Key.Option)
+		if current == nil {
+			return fmt.Errorf("invalid key in %s", op)
+		}
+		currentFields := strings.Fields(current.Value())
 		hasValue := false
-		for _, e := range current {
+		for _, e := range currentFields {
 			if e == op.Value {
 				hasValue = true
 				break
@@ -591,11 +609,15 @@ func (t *T) set(op keyop.T) error {
 	}
 
 	setInsert := func(op keyop.T) error {
-		current := strings.Fields(t.file.Section(op.Key.Section).Key(op.Key.Option).Value())
+		current := t.file.Section(op.Key.Section).Key(op.Key.Option)
+		if current == nil {
+			return fmt.Errorf("invalid key in %s", op)
+		}
+		currentFields := strings.Fields(current.Value())
 		target := []string{}
-		target = append(target, current[:op.Index]...)
+		target = append(target, currentFields[:op.Index]...)
 		target = append(target, op.Value)
-		target = append(target, current[op.Index:]...)
+		target = append(target, currentFields[op.Index:]...)
 		t.file.Section(op.Key.Section).Key(op.Key.Option).SetValue(strings.Join(target, " "))
 		t.changed = true
 		return nil
diff --git a/daemon/api/api.yaml b/daemon/api/api.yaml
index e5f7504dd..5d0ce271b 100644
--- a/daemon/api/api.yaml
+++ b/daemon/api/api.yaml
@@ -2343,6 +2343,221 @@ paths:
         500:
           $ref: '#/components/responses/500'
  
+  /object/path/{namespace}/{kind}/{name}/kvstore/keys:
+    get:
+      operationId: GetObjectKVStoreKeys
+      tags:
+        - object / cfg
+        - object / sec
+        - object / usr
+      security:
+        - basicAuth: []
+        - bearerAuth: []
+      parameters:
+        - $ref: '#/components/parameters/inPathNamespace'
+        - $ref: '#/components/parameters/inPathKind'
+        - $ref: '#/components/parameters/inPathName'
+      responses:
+        200:
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/KVStoreKeyList'
+        400:
+          $ref: '#/components/responses/400'
+        401:
+          $ref: '#/components/responses/401'
+        403:
+          $ref: '#/components/responses/403'
+        500:
+          $ref: '#/components/responses/500'
+
+  /object/path/{namespace}/{kind}/{name}/kvstore/entry:
+    get:
+      operationId: GetObjectKVStoreEntry
+      tags:
+        - object / cfg
+        - object / sec
+        - object / usr
+      security:
+        - basicAuth: []
+        - bearerAuth: []
+      parameters:
+        - $ref: '#/components/parameters/inPathNamespace'
+        - $ref: '#/components/parameters/inPathKind'
+        - $ref: '#/components/parameters/inPathName'
+        - $ref: '#/components/parameters/inQueryKey'
+      responses:
+        200:
+          content:
+            application/octet-stream:
+              schema:
+                type: string
+                format: binary
+        400:
+          $ref: '#/components/responses/400'
+        401:
+          $ref: '#/components/responses/401'
+        403:
+          $ref: '#/components/responses/403'
+        500:
+          $ref: '#/components/responses/500'
+
+    delete:
+      operationId: DeleteObjectKVStoreEntry
+      tags:
+        - object / cfg
+        - object / sec
+        - object / usr
+      security:
+        - basicAuth: []
+        - bearerAuth: []
+      parameters:
+        - $ref: '#/components/parameters/inPathNamespace'
+        - $ref: '#/components/parameters/inPathKind'
+        - $ref: '#/components/parameters/inPathName'
+        - $ref: '#/components/parameters/inQueryKey'
+      responses:
+        204:
+          $ref: '#/components/responses/204'
+        400:
+          $ref: '#/components/responses/400'
+        401:
+          $ref: '#/components/responses/401'
+        403:
+          $ref: '#/components/responses/403'
+        500:
+          $ref: '#/components/responses/500'
+
+    post:
+      operationId: PostObjectKVStoreEntry
+      tags:
+        - object / cfg
+        - object / sec
+        - object / usr
+      security:
+        - basicAuth: []
+        - bearerAuth: []
+      parameters:
+        - $ref: '#/components/parameters/inPathNamespace'
+        - $ref: '#/components/parameters/inPathKind'
+        - $ref: '#/components/parameters/inPathName'
+        - $ref: '#/components/parameters/inQueryKey'
+      requestBody:
+        required: true
+        content:
+          application/octet-stream:
+            schema:
+              type: string
+              format: binary
+      responses:
+        204:
+          $ref: '#/components/responses/204'
+        400:
+          $ref: '#/components/responses/400'
+        401:
+          $ref: '#/components/responses/401'
+        403:
+          $ref: '#/components/responses/403'
+        500:
+          $ref: '#/components/responses/500'
+
+    put:
+      operationId: PutObjectKVStoreEntry
+      tags:
+        - object / cfg
+        - object / sec
+        - object / usr
+      security:
+        - basicAuth: []
+        - bearerAuth: []
+      parameters:
+        - $ref: '#/components/parameters/inPathNamespace'
+        - $ref: '#/components/parameters/inPathKind'
+        - $ref: '#/components/parameters/inPathName'
+        - $ref: '#/components/parameters/inQueryKey'
+      requestBody:
+        required: true
+        content:
+          application/octet-stream:
+            schema:
+              type: string
+              format: binary
+      responses:
+        204:
+          $ref: '#/components/responses/204'
+        400:
+          $ref: '#/components/responses/400'
+        401:
+          $ref: '#/components/responses/401'
+        403:
+          $ref: '#/components/responses/403'
+        500:
+          $ref: '#/components/responses/500'
+
+  /object/path/{namespace}/{kind}/{name}/kvstore:
+    get:
+      operationId: GetObjectKVStore
+      tags:
+        - object / cfg
+        - object / sec
+        - object / usr
+      security:
+        - basicAuth: []
+        - bearerAuth: []
+      parameters:
+        - $ref: '#/components/parameters/inPathNamespace'
+        - $ref: '#/components/parameters/inPathKind'
+        - $ref: '#/components/parameters/inPathName'
+        - $ref: '#/components/parameters/inQueryKeys'
+      responses:
+        200:
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/KVStoreEntries'
+        400:
+          $ref: '#/components/responses/400'
+        401:
+          $ref: '#/components/responses/401'
+        403:
+          $ref: '#/components/responses/403'
+        500:
+          $ref: '#/components/responses/500'
+    patch:
+      operationId: PatchObjectKVStore
+      tags:
+        - object / cfg
+        - object / sec
+        - object / usr
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              $ref: '#/components/schemas/PatchKVStoreEntries'
+      security:
+        - basicAuth: []
+        - bearerAuth: []
+      parameters:
+        - $ref: '#/components/parameters/inPathNamespace'
+        - $ref: '#/components/parameters/inPathKind'
+        - $ref: '#/components/parameters/inPathName'
+      responses:
+        204:
+          $ref: '#/components/responses/204'
+        400:
+          $ref: '#/components/responses/400'
+        401:
+          $ref: '#/components/responses/401'
+        403:
+          $ref: '#/components/responses/403'
+        408:
+          $ref: '#/components/responses/408'
+        409:
+          $ref: '#/components/responses/409'
+        500:
+          $ref: '#/components/responses/500'
 
   /node/name/{nodename}/instance/path/{namespace}/{kind}/{name}/action/prstart:
     post:
@@ -5245,6 +5460,83 @@ components:
         restart:
           $ref: '#/components/schemas/ResourceMonitorRestart'
 
+    KVStoreEntries:
+        type: array
+        items:
+          $ref: '#/components/schemas/KVStoreEntry'
+
+    KVStoreEntry:
+      type: object
+      required:
+        - key
+        - bytes
+      properties:
+        key:
+          type: string
+        bytes:
+          type: string
+          format: byte
+
+    KVStoreKeyList:
+      type: object
+      required:
+        - kind
+        - items
+      properties:
+        kind:
+          type: string
+          enum:
+            - KVStoreKeyList
+        items:
+          $ref: '#/components/schemas/KVStoreKeyListItems'
+
+    KVStoreKeyListItems:
+        type: array
+        items:
+          $ref: '#/components/schemas/KVStoreKeyListItem'
+
+    KVStoreKeyListItem:
+      type: object
+      required:
+        - node
+        - object
+        - key
+        - size
+      properties:
+        node:
+          type: string
+        object:
+          type: string
+        key:
+          type: string
+        size:
+          type: integer
+
+    PatchKVStoreEntries:
+        type: array
+        items:
+          $ref: '#/components/schemas/PatchKVStoreEntry'
+
+    PatchKVStoreEntry:
+      type: object
+      required:
+        - action
+        - key
+      properties:
+        action:
+          type: string
+          enum:
+            - add
+            - change
+            - remove
+        key:
+          type: string
+        string:
+          type: string
+        bytes:
+          type: string
+          format: byte
+
     ResourceMonitorRestart:
       type: object
       required:
@@ -5708,6 +6000,24 @@ components:
       schema:
         type: string
 
+    inQueryKey:
+      in: query
+      name: key
+      required: true
+      schema:
+        type: string
+        description: A kvstore key name
+
+    inQueryKeys:
+      in: query
+      name: key
+      x-go-name: Keys
+      schema:
+        type: array
+        items:
+          type: string
+          description: A kvstore key name
+
     inQuerySets:
       in: query
       name: set
diff --git a/daemon/api/codegen_client_gen.go b/daemon/api/codegen_client_gen.go
index c6d95e0aa..4d5a7dd73 100644
--- a/daemon/api/codegen_client_gen.go
+++ b/daemon/api/codegen_client_gen.go
@@ -385,6 +385,29 @@ type ClientInterface interface {
 	// PostObjectConfigUpdate request
 	PostObjectConfigUpdate(ctx context.Context, namespace InPathNamespace, kind InPathKind, name InPathName, params *PostObjectConfigUpdateParams, reqEditors ...RequestEditorFn) (*http.Response, error)
 
+	// GetObjectKVStore request
+	GetObjectKVStore(ctx context.Context, namespace InPathNamespace, kind InPathKind, name InPathName, params *GetObjectKVStoreParams, reqEditors ...RequestEditorFn) (*http.Response, error)
+
+	// PatchObjectKVStoreWithBody request with any body
+	PatchObjectKVStoreWithBody(ctx context.Context, namespace InPathNamespace, kind InPathKind, name InPathName, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)
+
+	PatchObjectKVStore(ctx context.Context, namespace InPathNamespace, kind InPathKind, name InPathName, body PatchObjectKVStoreJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)
+
+	// DeleteObjectKVStoreEntry request
+	DeleteObjectKVStoreEntry(ctx context.Context, namespace InPathNamespace, kind InPathKind, name InPathName, params *DeleteObjectKVStoreEntryParams, reqEditors ...RequestEditorFn) (*http.Response, error)
+
+	// GetObjectKVStoreEntry request
+	GetObjectKVStoreEntry(ctx context.Context, namespace InPathNamespace, kind InPathKind, name InPathName, params *GetObjectKVStoreEntryParams, reqEditors ...RequestEditorFn) (*http.Response, error)
+
+	// PostObjectKVStoreEntryWithBody request with any body
+	PostObjectKVStoreEntryWithBody(ctx context.Context, namespace InPathNamespace, kind InPathKind, name InPathName, params *PostObjectKVStoreEntryParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)
+
+	// PutObjectKVStoreEntryWithBody request with any body
+	PutObjectKVStoreEntryWithBody(ctx context.Context, namespace InPathNamespace, kind InPathKind, name InPathName, params *PutObjectKVStoreEntryParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)
+
+	// GetObjectKVStoreKeys request
+	GetObjectKVStoreKeys(ctx context.Context, namespace InPathNamespace, kind InPathKind, name InPathName, reqEditors ...RequestEditorFn) (*http.Response, error)
+
 	// GetPools request
 	GetPools(ctx context.Context, params *GetPoolsParams, reqEditors ...RequestEditorFn) (*http.Response, error)
 
@@ -1621,6 +1644,102 @@ func (c *Client) PostObjectConfigUpdate(ctx context.Context, namespace InPathNam
 	return c.Client.Do(req)
 }
 
+func (c *Client) GetObjectKVStore(ctx context.Context, namespace InPathNamespace, kind InPathKind, name InPathName, params *GetObjectKVStoreParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
+	req, err := NewGetObjectKVStoreRequest(c.Server, namespace, kind, name, params)
+	if err != nil {
+		return nil, err
+	}
+	req = req.WithContext(ctx)
+	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
+		return nil, err
+	}
+	return c.Client.Do(req)
+}
+
+func (c *Client) PatchObjectKVStoreWithBody(ctx context.Context, namespace InPathNamespace, kind InPathKind, name InPathName, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
+	req, err := NewPatchObjectKVStoreRequestWithBody(c.Server, namespace, kind, name, contentType, body)
+	if err != nil {
+		return nil, err
+	}
+	req = req.WithContext(ctx)
+	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
+		return nil, err
+	}
+	return c.Client.Do(req)
+}
+
+func (c *Client) PatchObjectKVStore(ctx context.Context, namespace InPathNamespace, kind InPathKind, name InPathName, body PatchObjectKVStoreJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
+	req, err := NewPatchObjectKVStoreRequest(c.Server, namespace, kind, name, body)
+	if err != nil {
+		return nil, err
+	}
+	req = req.WithContext(ctx)
+	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
+		return nil, err
+	}
+	return c.Client.Do(req)
+}
+
+func (c *Client) DeleteObjectKVStoreEntry(ctx context.Context, namespace InPathNamespace, kind InPathKind, name InPathName, params *DeleteObjectKVStoreEntryParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
+	req, err := NewDeleteObjectKVStoreEntryRequest(c.Server, namespace, kind, name, params)
+	if err != nil {
+		return nil, err
+	}
+	req = req.WithContext(ctx)
+	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
+		return nil, err
+	}
+	return c.Client.Do(req)
+}
+
+func (c *Client) GetObjectKVStoreEntry(ctx context.Context, namespace InPathNamespace, kind InPathKind, name InPathName, params *GetObjectKVStoreEntryParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
+	req, err := NewGetObjectKVStoreEntryRequest(c.Server, namespace, kind, name, params)
+	if err != nil {
+		return nil, err
+	}
+	req = req.WithContext(ctx)
+	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
+		return nil, err
+	}
+	return c.Client.Do(req)
+}
+
+func (c *Client) PostObjectKVStoreEntryWithBody(ctx context.Context, namespace InPathNamespace, kind InPathKind, name InPathName, params *PostObjectKVStoreEntryParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
+	req, err := NewPostObjectKVStoreEntryRequestWithBody(c.Server, namespace, kind, name, params, contentType, body)
+	if err != nil {
+		return nil, err
+	}
+	req = req.WithContext(ctx)
+	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
+		return nil, err
+	}
+	return c.Client.Do(req)
+}
+
+func (c *Client) PutObjectKVStoreEntryWithBody(ctx context.Context, namespace InPathNamespace, kind InPathKind, name InPathName, params *PutObjectKVStoreEntryParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
+	req, err := NewPutObjectKVStoreEntryRequestWithBody(c.Server, namespace, kind, name, params, contentType, body)
+	if err != nil {
+		return nil, err
+	}
+	req = req.WithContext(ctx)
+	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
+		return nil, err
+	}
+	return c.Client.Do(req)
+}
+
+func (c *Client) GetObjectKVStoreKeys(ctx context.Context, namespace InPathNamespace, kind InPathKind, name InPathName, reqEditors ...RequestEditorFn) (*http.Response, error) {
+	req, err := NewGetObjectKVStoreKeysRequest(c.Server, namespace, kind, name)
+	if err != nil {
+		return nil, err
+	}
+	req = req.WithContext(ctx)
+	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
+		return nil, err
+	}
+	return c.Client.Do(req)
+}
+
 func (c *Client) GetPools(ctx context.Context, params *GetPoolsParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
 	req, err := NewGetPoolsRequest(c.Server, params)
 	if err != nil {
@@ -7722,65 +7841,37 @@ func NewPostObjectConfigUpdateRequest(server string, namespace InPathNamespace,
 	return req, nil
 }
 
-// NewGetPoolsRequest generates requests for GetPools
-func NewGetPoolsRequest(server string, params *GetPoolsParams) (*http.Request, error) {
+// NewGetObjectKVStoreRequest generates requests for GetObjectKVStore
+func NewGetObjectKVStoreRequest(server string, namespace InPathNamespace, kind InPathKind, name InPathName, params *GetObjectKVStoreParams) (*http.Request, error) {
 	var err error
 
-	serverURL, err := url.Parse(server)
+	var pathParam0 string
+
+	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "namespace", runtime.ParamLocationPath, namespace)
 	if err != nil {
 		return nil, err
 	}
 
-	operationPath := fmt.Sprintf("/pool")
-	if operationPath[0] == '/' {
-		operationPath = "." + operationPath
-	}
+	var pathParam1 string
 
-	queryURL, err := serverURL.Parse(operationPath)
+	pathParam1, err = runtime.StyleParamWithLocation("simple", false, "kind", runtime.ParamLocationPath, kind)
 	if err != nil {
 		return nil, err
 	}
 
-	if params != nil {
-		queryValues := queryURL.Query()
-
-		if params.Name != nil {
-
-			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "name", runtime.ParamLocationQuery, *params.Name); err != nil {
-				return nil, err
-			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
-				return nil, err
-			} else {
-				for k, v := range parsed {
-					for _, v2 := range v {
-						queryValues.Add(k, v2)
-					}
-				}
-			}
-
-		}
-
-		queryURL.RawQuery = queryValues.Encode()
-	}
+	var pathParam2 string
 
-	req, err := http.NewRequest("GET", queryURL.String(), nil)
+	pathParam2, err = runtime.StyleParamWithLocation("simple", false, "name", runtime.ParamLocationPath, name)
 	if err != nil {
 		return nil, err
 	}
 
-	return req, nil
-}
-
-// NewGetPoolVolumesRequest generates requests for GetPoolVolumes
-func NewGetPoolVolumesRequest(server string, params *GetPoolVolumesParams) (*http.Request, error) {
-	var err error
-
 	serverURL, err := url.Parse(server)
 	if err != nil {
 		return nil, err
 	}
 
-	operationPath := fmt.Sprintf("/pool/volume")
+	operationPath := fmt.Sprintf("/object/path/%s/%s/%s/kvstore", pathParam0, pathParam1, pathParam2)
 	if operationPath[0] == '/' {
 		operationPath = "." + operationPath
 	}
@@ -7793,9 +7884,9 @@ func NewGetPoolVolumesRequest(server string, params *GetPoolVolumesParams) (*htt
 	if params != nil {
 		queryValues := queryURL.Query()
 
-		if params.Name != nil {
+		if params.Keys != nil {
 
-			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "name", runtime.ParamLocationQuery, *params.Name); err != nil {
+			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "key", runtime.ParamLocationQuery, *params.Keys); err != nil {
 				return nil, err
 			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
 				return nil, err
@@ -7820,43 +7911,48 @@ func NewGetPoolVolumesRequest(server string, params *GetPoolVolumesParams) (*htt
 	return req, nil
 }
 
-// NewGetSwaggerRequest generates requests for GetSwagger
-func NewGetSwaggerRequest(server string) (*http.Request, error) {
-	var err error
-
-	serverURL, err := url.Parse(server)
+// NewPatchObjectKVStoreRequest calls the generic PatchObjectKVStore builder with application/json body
+func NewPatchObjectKVStoreRequest(server string, namespace InPathNamespace, kind InPathKind, name InPathName, body PatchObjectKVStoreJSONRequestBody) (*http.Request, error) {
+	var bodyReader io.Reader
+	buf, err := json.Marshal(body)
 	if err != nil {
 		return nil, err
 	}
+	bodyReader = bytes.NewReader(buf)
+	return NewPatchObjectKVStoreRequestWithBody(server, namespace, kind, name, "application/json", bodyReader)
+}
 
-	operationPath := fmt.Sprintf("/public/openapi")
-	if operationPath[0] == '/' {
-		operationPath = "." + operationPath
-	}
+// NewPatchObjectKVStoreRequestWithBody generates requests for PatchObjectKVStore with any type of body
+func NewPatchObjectKVStoreRequestWithBody(server string, namespace InPathNamespace, kind InPathKind, name InPathName, contentType string, body io.Reader) (*http.Request, error) {
+	var err error
 
-	queryURL, err := serverURL.Parse(operationPath)
+	var pathParam0 string
+
+	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "namespace", runtime.ParamLocationPath, namespace)
 	if err != nil {
 		return nil, err
 	}
 
-	req, err := http.NewRequest("GET", queryURL.String(), nil)
+	var pathParam1 string
+
+	pathParam1, err = runtime.StyleParamWithLocation("simple", false, "kind", runtime.ParamLocationPath, kind)
 	if err != nil {
 		return nil, err
 	}
 
-	return req, nil
-}
+	var pathParam2 string
 
-// NewGetRelayMessageRequest generates requests for GetRelayMessage
-func NewGetRelayMessageRequest(server string, params *GetRelayMessageParams) (*http.Request, error) {
-	var err error
+	pathParam2, err = runtime.StyleParamWithLocation("simple", false, "name", runtime.ParamLocationPath, name)
+	if err != nil {
+		return nil, err
+	}
 
 	serverURL, err := url.Parse(server)
 	if err != nil {
 		return nil, err
 	}
 
-	operationPath := fmt.Sprintf("/relay/message")
+	operationPath := fmt.Sprintf("/object/path/%s/%s/%s/kvstore", pathParam0, pathParam1, pathParam2)
 	if operationPath[0] == '/' {
 		operationPath = "." + operationPath
 	}
@@ -7866,73 +7962,47 @@ func NewGetRelayMessageRequest(server string, params *GetRelayMessageParams) (*h
 		return nil, err
 	}
 
-	if params != nil {
-		queryValues := queryURL.Query()
-
-		if params.Nodename != nil {
-
-			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "nodename", runtime.ParamLocationQuery, *params.Nodename); err != nil {
-				return nil, err
-			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
-				return nil, err
-			} else {
-				for k, v := range parsed {
-					for _, v2 := range v {
-						queryValues.Add(k, v2)
-					}
-				}
-			}
+	req, err := http.NewRequest("PATCH", queryURL.String(), body)
+	if err != nil {
+		return nil, err
+	}
 
-		}
+	req.Header.Add("Content-Type", contentType)
 
-		if params.ClusterID != nil {
+	return req, nil
+}
 
-			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "cluster_id", runtime.ParamLocationQuery, *params.ClusterID); err != nil {
-				return nil, err
-			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
-				return nil, err
-			} else {
-				for k, v := range parsed {
-					for _, v2 := range v {
-						queryValues.Add(k, v2)
-					}
-				}
-			}
+// NewDeleteObjectKVStoreEntryRequest generates requests for DeleteObjectKVStoreEntry
+func NewDeleteObjectKVStoreEntryRequest(server string, namespace InPathNamespace, kind InPathKind, name InPathName, params *DeleteObjectKVStoreEntryParams) (*http.Request, error) {
+	var err error
 
-		}
+	var pathParam0 string
 
-		queryURL.RawQuery = queryValues.Encode()
+	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "namespace", runtime.ParamLocationPath, namespace)
+	if err != nil {
+		return nil, err
 	}
 
-	req, err := http.NewRequest("GET", queryURL.String(), nil)
+	var pathParam1 string
+
+	pathParam1, err = runtime.StyleParamWithLocation("simple", false, "kind", runtime.ParamLocationPath, kind)
 	if err != nil {
 		return nil, err
 	}
 
-	return req, nil
-}
+	var pathParam2 string
 
-// NewPostRelayMessageRequest calls the generic PostRelayMessage builder with application/json body
-func NewPostRelayMessageRequest(server string, body PostRelayMessageJSONRequestBody) (*http.Request, error) {
-	var bodyReader io.Reader
-	buf, err := json.Marshal(body)
+	pathParam2, err = runtime.StyleParamWithLocation("simple", false, "name", runtime.ParamLocationPath, name)
 	if err != nil {
 		return nil, err
 	}
-	bodyReader = bytes.NewReader(buf)
-	return NewPostRelayMessageRequestWithBody(server, "application/json", bodyReader)
-}
-
-// NewPostRelayMessageRequestWithBody generates requests for PostRelayMessage with any type of body
-func NewPostRelayMessageRequestWithBody(server string, contentType string, body io.Reader) (*http.Request, error) {
-	var err error
 
 	serverURL, err := url.Parse(server)
 	if err != nil {
 		return nil, err
 	}
 
-	operationPath := fmt.Sprintf("/relay/message")
+	operationPath := fmt.Sprintf("/object/path/%s/%s/%s/kvstore/entry", pathParam0, pathParam1, pathParam2)
 	if operationPath[0] == '/' {
 		operationPath = "." + operationPath
 	}
@@ -7942,21 +8012,517 @@ func NewPostRelayMessageRequestWithBody(server string, contentType string, body
 		return nil, err
 	}
 
-	req, err := http.NewRequest("POST", queryURL.String(), body)
+	if params != nil {
+		queryValues := queryURL.Query()
+
+		if queryFrag, err := runtime.StyleParamWithLocation("form", true, "key", runtime.ParamLocationQuery, params.Key); err != nil {
+			return nil, err
+		} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
+			return nil, err
+		} else {
+			for k, v := range parsed {
+				for _, v2 := range v {
+					queryValues.Add(k, v2)
+				}
+			}
+		}
+
+		queryURL.RawQuery = queryValues.Encode()
+	}
+
+	req, err := http.NewRequest("DELETE", queryURL.String(), nil)
 	if err != nil {
 		return nil, err
 	}
 
-	req.Header.Add("Content-Type", contentType)
-
 	return req, nil
 }
 
-// NewGetResourcesRequest generates requests for GetResources
-func NewGetResourcesRequest(server string, params *GetResourcesParams) (*http.Request, error) {
+// NewGetObjectKVStoreEntryRequest generates requests for GetObjectKVStoreEntry
+func NewGetObjectKVStoreEntryRequest(server string, namespace InPathNamespace, kind InPathKind, name InPathName, params *GetObjectKVStoreEntryParams) (*http.Request, error) {
 	var err error
 
-	serverURL, err := url.Parse(server)
+	var pathParam0 string
+
+	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "namespace", runtime.ParamLocationPath, namespace)
+	if err != nil {
+		return nil, err
+	}
+
+	var pathParam1 string
+
+	pathParam1, err = runtime.StyleParamWithLocation("simple", false, "kind", runtime.ParamLocationPath, kind)
+	if err != nil {
+		return nil, err
+	}
+
+	var pathParam2 string
+
+	pathParam2, err = runtime.StyleParamWithLocation("simple", false, "name", runtime.ParamLocationPath, name)
+	if err != nil {
+		return nil, err
+	}
+
+	serverURL, err := url.Parse(server)
+	if err != nil {
+		return nil, err
+	}
+
+	operationPath := fmt.Sprintf("/object/path/%s/%s/%s/kvstore/entry", pathParam0, pathParam1, pathParam2)
+	if operationPath[0] == '/' {
+		operationPath = "." + operationPath
+	}
+
+	queryURL, err := serverURL.Parse(operationPath)
+	if err != nil {
+		return nil, err
+	}
+
+	if params != nil {
+		queryValues := queryURL.Query()
+
+		if queryFrag, err := runtime.StyleParamWithLocation("form", true, "key", runtime.ParamLocationQuery, params.Key); err != nil {
+			return nil, err
+		} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
+			return nil, err
+		} else {
+			for k, v := range parsed {
+				for _, v2 := range v {
+					queryValues.Add(k, v2)
+				}
+			}
+		}
+
+		queryURL.RawQuery = queryValues.Encode()
+	}
+
+	req, err := http.NewRequest("GET", queryURL.String(), nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return req, nil
+}
+
+// NewPostObjectKVStoreEntryRequestWithBody generates requests for PostObjectKVStoreEntry with any type of body
+func NewPostObjectKVStoreEntryRequestWithBody(server string, namespace InPathNamespace, kind InPathKind, name InPathName, params *PostObjectKVStoreEntryParams, contentType string, body io.Reader) (*http.Request, error) {
+	var err error
+
+	var pathParam0 string
+
+	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "namespace", runtime.ParamLocationPath, namespace)
+	if err != nil {
+		return nil, err
+	}
+
+	var pathParam1 string
+
+	pathParam1, err = runtime.StyleParamWithLocation("simple", false, "kind", runtime.ParamLocationPath, kind)
+	if err != nil {
+		return nil, err
+	}
+
+	var pathParam2 string
+
+	pathParam2, err = runtime.StyleParamWithLocation("simple", false, "name", runtime.ParamLocationPath, name)
+	if err != nil {
+		return nil, err
+	}
+
+	serverURL, err := url.Parse(server)
+	if err != nil {
+		return nil, err
+	}
+
+	operationPath := fmt.Sprintf("/object/path/%s/%s/%s/kvstore/entry", pathParam0, pathParam1, pathParam2)
+	if operationPath[0] == '/' {
+		operationPath = "." + operationPath
+	}
+
+	queryURL, err := serverURL.Parse(operationPath)
+	if err != nil {
+		return nil, err
+	}
+
+	if params != nil {
+		queryValues := queryURL.Query()
+
+		if queryFrag, err := runtime.StyleParamWithLocation("form", true, "key", runtime.ParamLocationQuery, params.Key); err != nil {
+			return nil, err
+		} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
+			return nil, err
+		} else {
+			for k, v := range parsed {
+				for _, v2 := range v {
+					queryValues.Add(k, v2)
+				}
+			}
+		}
+
+		queryURL.RawQuery = queryValues.Encode()
+	}
+
+	req, err := http.NewRequest("POST", queryURL.String(), body)
+	if err != nil {
+		return nil, err
+	}
+
+	req.Header.Add("Content-Type", contentType)
+
+	return req, nil
+}
+
+// NewPutObjectKVStoreEntryRequestWithBody generates requests for PutObjectKVStoreEntry with any type of body
+func NewPutObjectKVStoreEntryRequestWithBody(server string, namespace InPathNamespace, kind InPathKind, name InPathName, params *PutObjectKVStoreEntryParams, contentType string, body io.Reader) (*http.Request, error) {
+	var err error
+
+	var pathParam0 string
+
+	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "namespace", runtime.ParamLocationPath, namespace)
+	if err != nil {
+		return nil, err
+	}
+
+	var pathParam1 string
+
+	pathParam1, err = runtime.StyleParamWithLocation("simple", false, "kind", runtime.ParamLocationPath, kind)
+	if err != nil {
+		return nil, err
+	}
+
+	var pathParam2 string
+
+	pathParam2, err = runtime.StyleParamWithLocation("simple", false, "name", runtime.ParamLocationPath, name)
+	if err != nil {
+		return nil, err
+	}
+
+	serverURL, err := url.Parse(server)
+	if err != nil {
+		return nil, err
+	}
+
+	operationPath := fmt.Sprintf("/object/path/%s/%s/%s/kvstore/entry", pathParam0, pathParam1, pathParam2)
+	if operationPath[0] == '/' {
+		operationPath = "." + operationPath
+	}
+
+	queryURL, err := serverURL.Parse(operationPath)
+	if err != nil {
+		return nil, err
+	}
+
+	if params != nil {
+		queryValues := queryURL.Query()
+
+		if queryFrag, err := runtime.StyleParamWithLocation("form", true, "key", runtime.ParamLocationQuery, params.Key); err != nil {
+			return nil, err
+		} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
+			return nil, err
+		} else {
+			for k, v := range parsed {
+				for _, v2 := range v {
+					queryValues.Add(k, v2)
+				}
+			}
+		}
+
+		queryURL.RawQuery = queryValues.Encode()
+	}
+
+	req, err := http.NewRequest("PUT", queryURL.String(), body)
+	if err != nil {
+		return nil, err
+	}
+
+	req.Header.Add("Content-Type", contentType)
+
+	return req, nil
+}
+
+// NewGetObjectKVStoreKeysRequest generates requests for GetObjectKVStoreKeys
+func NewGetObjectKVStoreKeysRequest(server string, namespace InPathNamespace, kind InPathKind, name InPathName) (*http.Request, error) {
+	var err error
+
+	var pathParam0 string
+
+	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "namespace", runtime.ParamLocationPath, namespace)
+	if err != nil {
+		return nil, err
+	}
+
+	var pathParam1 string
+
+	pathParam1, err = runtime.StyleParamWithLocation("simple", false, "kind", runtime.ParamLocationPath, kind)
+	if err != nil {
+		return nil, err
+	}
+
+	var pathParam2 string
+
+	pathParam2, err = runtime.StyleParamWithLocation("simple", false, "name", runtime.ParamLocationPath, name)
+	if err != nil {
+		return nil, err
+	}
+
+	serverURL, err := url.Parse(server)
+	if err != nil {
+		return nil, err
+	}
+
+	operationPath := fmt.Sprintf("/object/path/%s/%s/%s/kvstore/keys", pathParam0, pathParam1, pathParam2)
+	if operationPath[0] == '/' {
+		operationPath = "." + operationPath
+	}
+
+	queryURL, err := serverURL.Parse(operationPath)
+	if err != nil {
+		return nil, err
+	}
+
+	req, err := http.NewRequest("GET", queryURL.String(), nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return req, nil
+}
+
+// NewGetPoolsRequest generates requests for GetPools
+func NewGetPoolsRequest(server string, params *GetPoolsParams) (*http.Request, error) {
+	var err error
+
+	serverURL, err := url.Parse(server)
+	if err != nil {
+		return nil, err
+	}
+
+	operationPath := fmt.Sprintf("/pool")
+	if operationPath[0] == '/' {
+		operationPath = "." + operationPath
+	}
+
+	queryURL, err := serverURL.Parse(operationPath)
+	if err != nil {
+		return nil, err
+	}
+
+	if params != nil {
+		queryValues := queryURL.Query()
+
+		if params.Name != nil {
+
+			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "name", runtime.ParamLocationQuery, *params.Name); err != nil {
+				return nil, err
+			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
+				return nil, err
+			} else {
+				for k, v := range parsed {
+					for _, v2 := range v {
+						queryValues.Add(k, v2)
+					}
+				}
+			}
+
+		}
+
+		queryURL.RawQuery = queryValues.Encode()
+	}
+
+	req, err := http.NewRequest("GET", queryURL.String(), nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return req, nil
+}
+
+// NewGetPoolVolumesRequest generates requests for GetPoolVolumes
+func NewGetPoolVolumesRequest(server string, params *GetPoolVolumesParams) (*http.Request, error) {
+	var err error
+
+	serverURL, err := url.Parse(server)
+	if err != nil {
+		return nil, err
+	}
+
+	operationPath := fmt.Sprintf("/pool/volume")
+	if operationPath[0] == '/' {
+		operationPath = "." + operationPath
+	}
+
+	queryURL, err := serverURL.Parse(operationPath)
+	if err != nil {
+		return nil, err
+	}
+
+	if params != nil {
+		queryValues := queryURL.Query()
+
+		if params.Name != nil {
+
+			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "name", runtime.ParamLocationQuery, *params.Name); err != nil {
+				return nil, err
+			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
+				return nil, err
+			} else {
+				for k, v := range parsed {
+					for _, v2 := range v {
+						queryValues.Add(k, v2)
+					}
+				}
+			}
+
+		}
+
+		queryURL.RawQuery = queryValues.Encode()
+	}
+
+	req, err := http.NewRequest("GET", queryURL.String(), nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return req, nil
+}
+
+// NewGetSwaggerRequest generates requests for GetSwagger
+func NewGetSwaggerRequest(server string) (*http.Request, error) {
+	var err error
+
+	serverURL, err := url.Parse(server)
+	if err != nil {
+		return nil, err
+	}
+
+	operationPath := fmt.Sprintf("/public/openapi")
+	if operationPath[0] == '/' {
+		operationPath = "." + operationPath
+	}
+
+	queryURL, err := serverURL.Parse(operationPath)
+	if err != nil {
+		return nil, err
+	}
+
+	req, err := http.NewRequest("GET", queryURL.String(), nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return req, nil
+}
+
+// NewGetRelayMessageRequest generates requests for GetRelayMessage
+func NewGetRelayMessageRequest(server string, params *GetRelayMessageParams) (*http.Request, error) {
+	var err error
+
+	serverURL, err := url.Parse(server)
+	if err != nil {
+		return nil, err
+	}
+
+	operationPath := fmt.Sprintf("/relay/message")
+	if operationPath[0] == '/' {
+		operationPath = "." + operationPath
+	}
+
+	queryURL, err := serverURL.Parse(operationPath)
+	if err != nil {
+		return nil, err
+	}
+
+	if params != nil {
+		queryValues := queryURL.Query()
+
+		if params.Nodename != nil {
+
+			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "nodename", runtime.ParamLocationQuery, *params.Nodename); err != nil {
+				return nil, err
+			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
+				return nil, err
+			} else {
+				for k, v := range parsed {
+					for _, v2 := range v {
+						queryValues.Add(k, v2)
+					}
+				}
+			}
+
+		}
+
+		if params.ClusterID != nil {
+
+			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "cluster_id", runtime.ParamLocationQuery, *params.ClusterID); err != nil {
+				return nil, err
+			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
+				return nil, err
+			} else {
+				for k, v := range parsed {
+					for _, v2 := range v {
+						queryValues.Add(k, v2)
+					}
+				}
+			}
+
+		}
+
+		queryURL.RawQuery = queryValues.Encode()
+	}
+
+	req, err := http.NewRequest("GET", queryURL.String(), nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return req, nil
+}
+
+// NewPostRelayMessageRequest calls the generic PostRelayMessage builder with application/json body
+func NewPostRelayMessageRequest(server string, body PostRelayMessageJSONRequestBody) (*http.Request, error) {
+	var bodyReader io.Reader
+	buf, err := json.Marshal(body)
+	if err != nil {
+		return nil, err
+	}
+	bodyReader = bytes.NewReader(buf)
+	return NewPostRelayMessageRequestWithBody(server, "application/json", bodyReader)
+}
+
+// NewPostRelayMessageRequestWithBody generates requests for PostRelayMessage with any type of body
+func NewPostRelayMessageRequestWithBody(server string, contentType string, body io.Reader) (*http.Request, error) {
+	var err error
+
+	serverURL, err := url.Parse(server)
+	if err != nil {
+		return nil, err
+	}
+
+	operationPath := fmt.Sprintf("/relay/message")
+	if operationPath[0] == '/' {
+		operationPath = "." + operationPath
+	}
+
+	queryURL, err := serverURL.Parse(operationPath)
+	if err != nil {
+		return nil, err
+	}
+
+	req, err := http.NewRequest("POST", queryURL.String(), body)
+	if err != nil {
+		return nil, err
+	}
+
+	req.Header.Add("Content-Type", contentType)
+
+	return req, nil
+}
+
+// NewGetResourcesRequest generates requests for GetResources
+func NewGetResourcesRequest(server string, params *GetResourcesParams) (*http.Request, error) {
+	var err error
+
+	serverURL, err := url.Parse(server)
 	if err != nil {
 		return nil, err
 	}
@@ -8399,6 +8965,29 @@ type ClientWithResponsesInterface interface {
 	// PostObjectConfigUpdateWithResponse request
 	PostObjectConfigUpdateWithResponse(ctx context.Context, namespace InPathNamespace, kind InPathKind, name InPathName, params *PostObjectConfigUpdateParams, reqEditors ...RequestEditorFn) (*PostObjectConfigUpdateResponse, error)
 
+	// GetObjectKVStoreWithResponse request
+	GetObjectKVStoreWithResponse(ctx context.Context, namespace InPathNamespace, kind InPathKind, name InPathName, params *GetObjectKVStoreParams, reqEditors ...RequestEditorFn) (*GetObjectKVStoreResponse, error)
+
+	// PatchObjectKVStoreWithBodyWithResponse request with any body
+	PatchObjectKVStoreWithBodyWithResponse(ctx context.Context, namespace InPathNamespace, kind InPathKind, name InPathName, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PatchObjectKVStoreResponse, error)
+
+	PatchObjectKVStoreWithResponse(ctx context.Context, namespace InPathNamespace, kind InPathKind, name InPathName, body PatchObjectKVStoreJSONRequestBody, reqEditors ...RequestEditorFn) (*PatchObjectKVStoreResponse, error)
+
+	// DeleteObjectKVStoreEntryWithResponse request
+	DeleteObjectKVStoreEntryWithResponse(ctx context.Context, namespace InPathNamespace, kind InPathKind, name InPathName, params *DeleteObjectKVStoreEntryParams, reqEditors ...RequestEditorFn) (*DeleteObjectKVStoreEntryResponse, error)
+
+	// GetObjectKVStoreEntryWithResponse request
+	GetObjectKVStoreEntryWithResponse(ctx context.Context, namespace InPathNamespace, kind InPathKind, name InPathName, params *GetObjectKVStoreEntryParams, reqEditors ...RequestEditorFn) (*GetObjectKVStoreEntryResponse, error)
+
+	// PostObjectKVStoreEntryWithBodyWithResponse request with any body
+	PostObjectKVStoreEntryWithBodyWithResponse(ctx context.Context, namespace InPathNamespace, kind InPathKind, name InPathName, params *PostObjectKVStoreEntryParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostObjectKVStoreEntryResponse, error)
+
+	// PutObjectKVStoreEntryWithBodyWithResponse request with any body
+	PutObjectKVStoreEntryWithBodyWithResponse(ctx context.Context, namespace InPathNamespace, kind InPathKind, name InPathName, params *PutObjectKVStoreEntryParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PutObjectKVStoreEntryResponse, error)
+
+	// GetObjectKVStoreKeysWithResponse request
+	GetObjectKVStoreKeysWithResponse(ctx context.Context, namespace InPathNamespace, kind InPathKind, name InPathName, reqEditors ...RequestEditorFn) (*GetObjectKVStoreKeysResponse, error)
+
 	// GetPoolsWithResponse request
 	GetPoolsWithResponse(ctx context.Context, params *GetPoolsParams, reqEditors ...RequestEditorFn) (*GetPoolsResponse, error)
 
@@ -10869,6 +11458,185 @@ func (r PostObjectConfigUpdateResponse) StatusCode() int {
 	return 0
 }
 
+type GetObjectKVStoreResponse struct {
+	Body         []byte
+	HTTPResponse *http.Response
+	JSON200      *KVStoreEntries
+	JSON400      *N400
+	JSON401      *N401
+	JSON403      *N403
+	JSON500      *N500
+}
+
+// Status returns HTTPResponse.Status
+func (r GetObjectKVStoreResponse) Status() string {
+	if r.HTTPResponse != nil {
+		return r.HTTPResponse.Status
+	}
+	return http.StatusText(0)
+}
+
+// StatusCode returns HTTPResponse.StatusCode
+func (r GetObjectKVStoreResponse) StatusCode() int {
+	if r.HTTPResponse != nil {
+		return r.HTTPResponse.StatusCode
+	}
+	return 0
+}
+
+type PatchObjectKVStoreResponse struct {
+	Body         []byte
+	HTTPResponse *http.Response
+	JSON400      *N400
+	JSON401      *N401
+	JSON403      *N403
+	JSON408      *N408
+	JSON409      *N409
+	JSON500      *N500
+}
+
+// Status returns HTTPResponse.Status
+func (r PatchObjectKVStoreResponse) Status() string {
+	if r.HTTPResponse != nil {
+		return r.HTTPResponse.Status
+	}
+	return http.StatusText(0)
+}
+
+// StatusCode returns HTTPResponse.StatusCode
+func (r PatchObjectKVStoreResponse) StatusCode() int {
+	if r.HTTPResponse != nil {
+		return r.HTTPResponse.StatusCode
+	}
+	return 0
+}
+
+type DeleteObjectKVStoreEntryResponse struct {
+	Body         []byte
+	HTTPResponse *http.Response
+	JSON400      *N400
+	JSON401      *N401
+	JSON403      *N403
+	JSON500      *N500
+}
+
+// Status returns HTTPResponse.Status
+func (r DeleteObjectKVStoreEntryResponse) Status() string {
+	if r.HTTPResponse != nil {
+		return r.HTTPResponse.Status
+	}
+	return http.StatusText(0)
+}
+
+// StatusCode returns HTTPResponse.StatusCode
+func (r DeleteObjectKVStoreEntryResponse) StatusCode() int {
+	if r.HTTPResponse != nil {
+		return r.HTTPResponse.StatusCode
+	}
+	return 0
+}
+
+type GetObjectKVStoreEntryResponse struct {
+	Body         []byte
+	HTTPResponse *http.Response
+	JSON400      *N400
+	JSON401      *N401
+	JSON403      *N403
+	JSON500      *N500
+}
+
+// Status returns HTTPResponse.Status
+func (r GetObjectKVStoreEntryResponse) Status() string {
+	if r.HTTPResponse != nil {
+		return r.HTTPResponse.Status
+	}
+	return http.StatusText(0)
+}
+
+// StatusCode returns HTTPResponse.StatusCode
+func (r GetObjectKVStoreEntryResponse) StatusCode() int {
+	if r.HTTPResponse != nil {
+		return r.HTTPResponse.StatusCode
+	}
+	return 0
+}
+
+type PostObjectKVStoreEntryResponse struct {
+	Body         []byte
+	HTTPResponse *http.Response
+	JSON400      *N400
+	JSON401      *N401
+	JSON403      *N403
+	JSON500      *N500
+}
+
+// Status returns HTTPResponse.Status
+func (r PostObjectKVStoreEntryResponse) Status() string {
+	if r.HTTPResponse != nil {
+		return r.HTTPResponse.Status
+	}
+	return http.StatusText(0)
+}
+
+// StatusCode returns HTTPResponse.StatusCode
+func (r PostObjectKVStoreEntryResponse) StatusCode() int {
+	if r.HTTPResponse != nil {
+		return r.HTTPResponse.StatusCode
+	}
+	return 0
+}
+
+type PutObjectKVStoreEntryResponse struct {
+	Body         []byte
+	HTTPResponse *http.Response
+	JSON400      *N400
+	JSON401      *N401
+	JSON403      *N403
+	JSON500      *N500
+}
+
+// Status returns HTTPResponse.Status
+func (r PutObjectKVStoreEntryResponse) Status() string {
+	if r.HTTPResponse != nil {
+		return r.HTTPResponse.Status
+	}
+	return http.StatusText(0)
+}
+
+// StatusCode returns HTTPResponse.StatusCode
+func (r PutObjectKVStoreEntryResponse) StatusCode() int {
+	if r.HTTPResponse != nil {
+		return r.HTTPResponse.StatusCode
+	}
+	return 0
+}
+
+type GetObjectKVStoreKeysResponse struct {
+	Body         []byte
+	HTTPResponse *http.Response
+	JSON200      *KVStoreKeyList
+	JSON400      *N400
+	JSON401      *N401
+	JSON403      *N403
+	JSON500      *N500
+}
+
+// Status returns HTTPResponse.Status
+func (r GetObjectKVStoreKeysResponse) Status() string {
+	if r.HTTPResponse != nil {
+		return r.HTTPResponse.Status
+	}
+	return http.StatusText(0)
+}
+
+// StatusCode returns HTTPResponse.StatusCode
+func (r GetObjectKVStoreKeysResponse) StatusCode() int {
+	if r.HTTPResponse != nil {
+		return r.HTTPResponse.StatusCode
+	}
+	return 0
+}
+
 type GetPoolsResponse struct {
 	Body         []byte
 	HTTPResponse *http.Response
@@ -11871,79 +12639,150 @@ func (c *ClientWithResponses) PostObjectActionSwitchWithResponse(ctx context.Con
 	if err != nil {
 		return nil, err
 	}
-	return ParsePostObjectActionSwitchResponse(rsp)
+	return ParsePostObjectActionSwitchResponse(rsp)
+}
+
+// PostObjectActionUnfreezeWithResponse request returning *PostObjectActionUnfreezeResponse
+func (c *ClientWithResponses) PostObjectActionUnfreezeWithResponse(ctx context.Context, namespace InPathNamespace, kind InPathKind, name InPathName, reqEditors ...RequestEditorFn) (*PostObjectActionUnfreezeResponse, error) {
+	rsp, err := c.PostObjectActionUnfreeze(ctx, namespace, kind, name, reqEditors...)
+	if err != nil {
+		return nil, err
+	}
+	return ParsePostObjectActionUnfreezeResponse(rsp)
+}
+
+// PostObjectActionUnprovisionWithResponse request returning *PostObjectActionUnprovisionResponse
+func (c *ClientWithResponses) PostObjectActionUnprovisionWithResponse(ctx context.Context, namespace InPathNamespace, kind InPathKind, name InPathName, reqEditors ...RequestEditorFn) (*PostObjectActionUnprovisionResponse, error) {
+	rsp, err := c.PostObjectActionUnprovision(ctx, namespace, kind, name, reqEditors...)
+	if err != nil {
+		return nil, err
+	}
+	return ParsePostObjectActionUnprovisionResponse(rsp)
+}
+
+// GetObjectConfigWithResponse request returning *GetObjectConfigResponse
+func (c *ClientWithResponses) GetObjectConfigWithResponse(ctx context.Context, namespace InPathNamespace, kind InPathKind, name InPathName, params *GetObjectConfigParams, reqEditors ...RequestEditorFn) (*GetObjectConfigResponse, error) {
+	rsp, err := c.GetObjectConfig(ctx, namespace, kind, name, params, reqEditors...)
+	if err != nil {
+		return nil, err
+	}
+	return ParseGetObjectConfigResponse(rsp)
+}
+
+// GetObjectConfigFileWithResponse request returning *GetObjectConfigFileResponse
+func (c *ClientWithResponses) GetObjectConfigFileWithResponse(ctx context.Context, namespace InPathNamespace, kind InPathKind, name InPathName, reqEditors ...RequestEditorFn) (*GetObjectConfigFileResponse, error) {
+	rsp, err := c.GetObjectConfigFile(ctx, namespace, kind, name, reqEditors...)
+	if err != nil {
+		return nil, err
+	}
+	return ParseGetObjectConfigFileResponse(rsp)
+}
+
+// PostObjectConfigFileWithBodyWithResponse request with arbitrary body returning *PostObjectConfigFileResponse
+func (c *ClientWithResponses) PostObjectConfigFileWithBodyWithResponse(ctx context.Context, namespace InPathNamespace, kind InPathKind, name InPathName, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostObjectConfigFileResponse, error) {
+	rsp, err := c.PostObjectConfigFileWithBody(ctx, namespace, kind, name, contentType, body, reqEditors...)
+	if err != nil {
+		return nil, err
+	}
+	return ParsePostObjectConfigFileResponse(rsp)
+}
+
+// PutObjectConfigFileWithBodyWithResponse request with arbitrary body returning *PutObjectConfigFileResponse
+func (c *ClientWithResponses) PutObjectConfigFileWithBodyWithResponse(ctx context.Context, namespace InPathNamespace, kind InPathKind, name InPathName, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PutObjectConfigFileResponse, error) {
+	rsp, err := c.PutObjectConfigFileWithBody(ctx, namespace, kind, name, contentType, body, reqEditors...)
+	if err != nil {
+		return nil, err
+	}
+	return ParsePutObjectConfigFileResponse(rsp)
+}
+
+// GetObjectConfigGetWithResponse request returning *GetObjectConfigGetResponse
+func (c *ClientWithResponses) GetObjectConfigGetWithResponse(ctx context.Context, namespace InPathNamespace, kind InPathKind, name InPathName, params *GetObjectConfigGetParams, reqEditors ...RequestEditorFn) (*GetObjectConfigGetResponse, error) {
+	rsp, err := c.GetObjectConfigGet(ctx, namespace, kind, name, params, reqEditors...)
+	if err != nil {
+		return nil, err
+	}
+	return ParseGetObjectConfigGetResponse(rsp)
+}
+
+// PostObjectConfigUpdateWithResponse request returning *PostObjectConfigUpdateResponse
+func (c *ClientWithResponses) PostObjectConfigUpdateWithResponse(ctx context.Context, namespace InPathNamespace, kind InPathKind, name InPathName, params *PostObjectConfigUpdateParams, reqEditors ...RequestEditorFn) (*PostObjectConfigUpdateResponse, error) {
+	rsp, err := c.PostObjectConfigUpdate(ctx, namespace, kind, name, params, reqEditors...)
+	if err != nil {
+		return nil, err
+	}
+	return ParsePostObjectConfigUpdateResponse(rsp)
 }
 
-// PostObjectActionUnfreezeWithResponse request returning *PostObjectActionUnfreezeResponse
-func (c *ClientWithResponses) PostObjectActionUnfreezeWithResponse(ctx context.Context, namespace InPathNamespace, kind InPathKind, name InPathName, reqEditors ...RequestEditorFn) (*PostObjectActionUnfreezeResponse, error) {
-	rsp, err := c.PostObjectActionUnfreeze(ctx, namespace, kind, name, reqEditors...)
+// GetObjectKVStoreWithResponse request returning *GetObjectKVStoreResponse
+func (c *ClientWithResponses) GetObjectKVStoreWithResponse(ctx context.Context, namespace InPathNamespace, kind InPathKind, name InPathName, params *GetObjectKVStoreParams, reqEditors ...RequestEditorFn) (*GetObjectKVStoreResponse, error) {
+	rsp, err := c.GetObjectKVStore(ctx, namespace, kind, name, params, reqEditors...)
 	if err != nil {
 		return nil, err
 	}
-	return ParsePostObjectActionUnfreezeResponse(rsp)
+	return ParseGetObjectKVStoreResponse(rsp)
 }
 
-// PostObjectActionUnprovisionWithResponse request returning *PostObjectActionUnprovisionResponse
-func (c *ClientWithResponses) PostObjectActionUnprovisionWithResponse(ctx context.Context, namespace InPathNamespace, kind InPathKind, name InPathName, reqEditors ...RequestEditorFn) (*PostObjectActionUnprovisionResponse, error) {
-	rsp, err := c.PostObjectActionUnprovision(ctx, namespace, kind, name, reqEditors...)
+// PatchObjectKVStoreWithBodyWithResponse request with arbitrary body returning *PatchObjectKVStoreResponse
+func (c *ClientWithResponses) PatchObjectKVStoreWithBodyWithResponse(ctx context.Context, namespace InPathNamespace, kind InPathKind, name InPathName, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PatchObjectKVStoreResponse, error) {
+	rsp, err := c.PatchObjectKVStoreWithBody(ctx, namespace, kind, name, contentType, body, reqEditors...)
 	if err != nil {
 		return nil, err
 	}
-	return ParsePostObjectActionUnprovisionResponse(rsp)
+	return ParsePatchObjectKVStoreResponse(rsp)
 }
 
-// GetObjectConfigWithResponse request returning *GetObjectConfigResponse
-func (c *ClientWithResponses) GetObjectConfigWithResponse(ctx context.Context, namespace InPathNamespace, kind InPathKind, name InPathName, params *GetObjectConfigParams, reqEditors ...RequestEditorFn) (*GetObjectConfigResponse, error) {
-	rsp, err := c.GetObjectConfig(ctx, namespace, kind, name, params, reqEditors...)
+func (c *ClientWithResponses) PatchObjectKVStoreWithResponse(ctx context.Context, namespace InPathNamespace, kind InPathKind, name InPathName, body PatchObjectKVStoreJSONRequestBody, reqEditors ...RequestEditorFn) (*PatchObjectKVStoreResponse, error) {
+	rsp, err := c.PatchObjectKVStore(ctx, namespace, kind, name, body, reqEditors...)
 	if err != nil {
 		return nil, err
 	}
-	return ParseGetObjectConfigResponse(rsp)
+	return ParsePatchObjectKVStoreResponse(rsp)
 }
 
-// GetObjectConfigFileWithResponse request returning *GetObjectConfigFileResponse
-func (c *ClientWithResponses) GetObjectConfigFileWithResponse(ctx context.Context, namespace InPathNamespace, kind InPathKind, name InPathName, reqEditors ...RequestEditorFn) (*GetObjectConfigFileResponse, error) {
-	rsp, err := c.GetObjectConfigFile(ctx, namespace, kind, name, reqEditors...)
+// DeleteObjectKVStoreEntryWithResponse request returning *DeleteObjectKVStoreEntryResponse
+func (c *ClientWithResponses) DeleteObjectKVStoreEntryWithResponse(ctx context.Context, namespace InPathNamespace, kind InPathKind, name InPathName, params *DeleteObjectKVStoreEntryParams, reqEditors ...RequestEditorFn) (*DeleteObjectKVStoreEntryResponse, error) {
+	rsp, err := c.DeleteObjectKVStoreEntry(ctx, namespace, kind, name, params, reqEditors...)
 	if err != nil {
 		return nil, err
 	}
-	return ParseGetObjectConfigFileResponse(rsp)
+	return ParseDeleteObjectKVStoreEntryResponse(rsp)
 }
 
-// PostObjectConfigFileWithBodyWithResponse request with arbitrary body returning *PostObjectConfigFileResponse
-func (c *ClientWithResponses) PostObjectConfigFileWithBodyWithResponse(ctx context.Context, namespace InPathNamespace, kind InPathKind, name InPathName, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostObjectConfigFileResponse, error) {
-	rsp, err := c.PostObjectConfigFileWithBody(ctx, namespace, kind, name, contentType, body, reqEditors...)
+// GetObjectKVStoreEntryWithResponse request returning *GetObjectKVStoreEntryResponse
+func (c *ClientWithResponses) GetObjectKVStoreEntryWithResponse(ctx context.Context, namespace InPathNamespace, kind InPathKind, name InPathName, params *GetObjectKVStoreEntryParams, reqEditors ...RequestEditorFn) (*GetObjectKVStoreEntryResponse, error) {
+	rsp, err := c.GetObjectKVStoreEntry(ctx, namespace, kind, name, params, reqEditors...)
 	if err != nil {
 		return nil, err
 	}
-	return ParsePostObjectConfigFileResponse(rsp)
+	return ParseGetObjectKVStoreEntryResponse(rsp)
 }
 
-// PutObjectConfigFileWithBodyWithResponse request with arbitrary body returning *PutObjectConfigFileResponse
-func (c *ClientWithResponses) PutObjectConfigFileWithBodyWithResponse(ctx context.Context, namespace InPathNamespace, kind InPathKind, name InPathName, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PutObjectConfigFileResponse, error) {
-	rsp, err := c.PutObjectConfigFileWithBody(ctx, namespace, kind, name, contentType, body, reqEditors...)
+// PostObjectKVStoreEntryWithBodyWithResponse request with arbitrary body returning *PostObjectKVStoreEntryResponse
+func (c *ClientWithResponses) PostObjectKVStoreEntryWithBodyWithResponse(ctx context.Context, namespace InPathNamespace, kind InPathKind, name InPathName, params *PostObjectKVStoreEntryParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostObjectKVStoreEntryResponse, error) {
+	rsp, err := c.PostObjectKVStoreEntryWithBody(ctx, namespace, kind, name, params, contentType, body, reqEditors...)
 	if err != nil {
 		return nil, err
 	}
-	return ParsePutObjectConfigFileResponse(rsp)
+	return ParsePostObjectKVStoreEntryResponse(rsp)
 }
 
-// GetObjectConfigGetWithResponse request returning *GetObjectConfigGetResponse
-func (c *ClientWithResponses) GetObjectConfigGetWithResponse(ctx context.Context, namespace InPathNamespace, kind InPathKind, name InPathName, params *GetObjectConfigGetParams, reqEditors ...RequestEditorFn) (*GetObjectConfigGetResponse, error) {
-	rsp, err := c.GetObjectConfigGet(ctx, namespace, kind, name, params, reqEditors...)
+// PutObjectKVStoreEntryWithBodyWithResponse request with arbitrary body returning *PutObjectKVStoreEntryResponse
+func (c *ClientWithResponses) PutObjectKVStoreEntryWithBodyWithResponse(ctx context.Context, namespace InPathNamespace, kind InPathKind, name InPathName, params *PutObjectKVStoreEntryParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PutObjectKVStoreEntryResponse, error) {
+	rsp, err := c.PutObjectKVStoreEntryWithBody(ctx, namespace, kind, name, params, contentType, body, reqEditors...)
 	if err != nil {
 		return nil, err
 	}
-	return ParseGetObjectConfigGetResponse(rsp)
+	return ParsePutObjectKVStoreEntryResponse(rsp)
 }
 
-// PostObjectConfigUpdateWithResponse request returning *PostObjectConfigUpdateResponse
-func (c *ClientWithResponses) PostObjectConfigUpdateWithResponse(ctx context.Context, namespace InPathNamespace, kind InPathKind, name InPathName, params *PostObjectConfigUpdateParams, reqEditors ...RequestEditorFn) (*PostObjectConfigUpdateResponse, error) {
-	rsp, err := c.PostObjectConfigUpdate(ctx, namespace, kind, name, params, reqEditors...)
+// GetObjectKVStoreKeysWithResponse request returning *GetObjectKVStoreKeysResponse
+func (c *ClientWithResponses) GetObjectKVStoreKeysWithResponse(ctx context.Context, namespace InPathNamespace, kind InPathKind, name InPathName, reqEditors ...RequestEditorFn) (*GetObjectKVStoreKeysResponse, error) {
+	rsp, err := c.GetObjectKVStoreKeys(ctx, namespace, kind, name, reqEditors...)
 	if err != nil {
 		return nil, err
 	}
-	return ParsePostObjectConfigUpdateResponse(rsp)
+	return ParseGetObjectKVStoreKeysResponse(rsp)
 }
 
 // GetPoolsWithResponse request returning *GetPoolsResponse
@@ -12014,56 +12853,314 @@ func (c *ClientWithResponses) GetwhoamiWithResponse(ctx context.Context, reqEdit
 	if err != nil {
 		return nil, err
 	}
-	return ParseGetwhoamiResponse(rsp)
+	return ParseGetwhoamiResponse(rsp)
+}
+
+// ParseGetAuthInfoResponse parses an HTTP response from a GetAuthInfoWithResponse call
+func ParseGetAuthInfoResponse(rsp *http.Response) (*GetAuthInfoResponse, error) {
+	bodyBytes, err := io.ReadAll(rsp.Body)
+	defer func() { _ = rsp.Body.Close() }()
+	if err != nil {
+		return nil, err
+	}
+
+	response := &GetAuthInfoResponse{
+		Body:         bodyBytes,
+		HTTPResponse: rsp,
+	}
+
+	switch {
+	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
+		var dest AuthInfo
+		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
+			return nil, err
+		}
+		response.JSON200 = &dest
+
+	}
+
+	return response, nil
+}
+
+// ParsePostAuthTokenResponse parses an HTTP response from a PostAuthTokenWithResponse call
+func ParsePostAuthTokenResponse(rsp *http.Response) (*PostAuthTokenResponse, error) {
+	bodyBytes, err := io.ReadAll(rsp.Body)
+	defer func() { _ = rsp.Body.Close() }()
+	if err != nil {
+		return nil, err
+	}
+
+	response := &PostAuthTokenResponse{
+		Body:         bodyBytes,
+		HTTPResponse: rsp,
+	}
+
+	switch {
+	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
+		var dest AuthToken
+		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
+			return nil, err
+		}
+		response.JSON200 = &dest
+
+	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
+		var dest N400
+		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
+			return nil, err
+		}
+		response.JSON400 = &dest
+
+	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401:
+		var dest N401
+		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
+			return nil, err
+		}
+		response.JSON401 = &dest
+
+	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 403:
+		var dest N403
+		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
+			return nil, err
+		}
+		response.JSON403 = &dest
+
+	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 500:
+		var dest N500
+		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
+			return nil, err
+		}
+		response.JSON500 = &dest
+
+	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 503:
+		var dest N503
+		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
+			return nil, err
+		}
+		response.JSON503 = &dest
+
+	}
+
+	return response, nil
+}
+
+// ParsePostClusterActionAbortResponse parses an HTTP response from a PostClusterActionAbortWithResponse call
+func ParsePostClusterActionAbortResponse(rsp *http.Response) (*PostClusterActionAbortResponse, error) {
+	bodyBytes, err := io.ReadAll(rsp.Body)
+	defer func() { _ = rsp.Body.Close() }()
+	if err != nil {
+		return nil, err
+	}
+
+	response := &PostClusterActionAbortResponse{
+		Body:         bodyBytes,
+		HTTPResponse: rsp,
+	}
+
+	switch {
+	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
+		var dest OrchestrationQueued
+		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
+			return nil, err
+		}
+		response.JSON200 = &dest
+
+	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
+		var dest N400
+		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
+			return nil, err
+		}
+		response.JSON400 = &dest
+
+	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401:
+		var dest N401
+		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
+			return nil, err
+		}
+		response.JSON401 = &dest
+
+	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 403:
+		var dest N403
+		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
+			return nil, err
+		}
+		response.JSON403 = &dest
+
+	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 408:
+		var dest N408
+		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
+			return nil, err
+		}
+		response.JSON408 = &dest
+
+	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 409:
+		var dest N409
+		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
+			return nil, err
+		}
+		response.JSON409 = &dest
+
+	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 500:
+		var dest N500
+		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
+			return nil, err
+		}
+		response.JSON500 = &dest
+
+	}
+
+	return response, nil
+}
+
+// ParsePostClusterActionFreezeResponse parses an HTTP response from a PostClusterActionFreezeWithResponse call
+func ParsePostClusterActionFreezeResponse(rsp *http.Response) (*PostClusterActionFreezeResponse, error) {
+	bodyBytes, err := io.ReadAll(rsp.Body)
+	defer func() { _ = rsp.Body.Close() }()
+	if err != nil {
+		return nil, err
+	}
+
+	response := &PostClusterActionFreezeResponse{
+		Body:         bodyBytes,
+		HTTPResponse: rsp,
+	}
+
+	switch {
+	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
+		var dest OrchestrationQueued
+		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
+			return nil, err
+		}
+		response.JSON200 = &dest
+
+	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
+		var dest N400
+		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
+			return nil, err
+		}
+		response.JSON400 = &dest
+
+	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401:
+		var dest N401
+		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
+			return nil, err
+		}
+		response.JSON401 = &dest
+
+	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 403:
+		var dest N403
+		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
+			return nil, err
+		}
+		response.JSON403 = &dest
+
+	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 408:
+		var dest N408
+		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
+			return nil, err
+		}
+		response.JSON408 = &dest
+
+	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 409:
+		var dest N409
+		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
+			return nil, err
+		}
+		response.JSON409 = &dest
+
+	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 500:
+		var dest N500
+		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
+			return nil, err
+		}
+		response.JSON500 = &dest
+
+	}
+
+	return response, nil
 }
 
-// ParseGetAuthInfoResponse parses an HTTP response from a GetAuthInfoWithResponse call
-func ParseGetAuthInfoResponse(rsp *http.Response) (*GetAuthInfoResponse, error) {
+// ParsePostClusterActionUnfreezeResponse parses an HTTP response from a PostClusterActionUnfreezeWithResponse call
+func ParsePostClusterActionUnfreezeResponse(rsp *http.Response) (*PostClusterActionUnfreezeResponse, error) {
 	bodyBytes, err := io.ReadAll(rsp.Body)
 	defer func() { _ = rsp.Body.Close() }()
 	if err != nil {
 		return nil, err
 	}
 
-	response := &GetAuthInfoResponse{
+	response := &PostClusterActionUnfreezeResponse{
 		Body:         bodyBytes,
 		HTTPResponse: rsp,
 	}
 
 	switch {
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
-		var dest AuthInfo
+		var dest OrchestrationQueued
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
 			return nil, err
 		}
 		response.JSON200 = &dest
 
+	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
+		var dest N400
+		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
+			return nil, err
+		}
+		response.JSON400 = &dest
+
+	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401:
+		var dest N401
+		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
+			return nil, err
+		}
+		response.JSON401 = &dest
+
+	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 403:
+		var dest N403
+		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
+			return nil, err
+		}
+		response.JSON403 = &dest
+
+	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 408:
+		var dest N408
+		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
+			return nil, err
+		}
+		response.JSON408 = &dest
+
+	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 409:
+		var dest N409
+		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
+			return nil, err
+		}
+		response.JSON409 = &dest
+
+	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 500:
+		var dest N500
+		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
+			return nil, err
+		}
+		response.JSON500 = &dest
+
 	}
 
 	return response, nil
 }
 
-// ParsePostAuthTokenResponse parses an HTTP response from a PostAuthTokenWithResponse call
-func ParsePostAuthTokenResponse(rsp *http.Response) (*PostAuthTokenResponse, error) {
+// ParsePostDaemonJoinResponse parses an HTTP response from a PostDaemonJoinWithResponse call
+func ParsePostDaemonJoinResponse(rsp *http.Response) (*PostDaemonJoinResponse, error) {
 	bodyBytes, err := io.ReadAll(rsp.Body)
 	defer func() { _ = rsp.Body.Close() }()
 	if err != nil {
 		return nil, err
 	}
 
-	response := &PostAuthTokenResponse{
+	response := &PostDaemonJoinResponse{
 		Body:         bodyBytes,
 		HTTPResponse: rsp,
 	}
 
 	switch {
-	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
-		var dest AuthToken
-		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
-			return nil, err
-		}
-		response.JSON200 = &dest
-
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
 		var dest N400
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
@@ -12092,34 +13189,53 @@ func ParsePostAuthTokenResponse(rsp *http.Response) (*PostAuthTokenResponse, err
 		}
 		response.JSON500 = &dest
 
-	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 503:
-		var dest N503
+	}
+
+	return response, nil
+}
+
+// ParsePostDaemonLeaveResponse parses an HTTP response from a PostDaemonLeaveWithResponse call
+func ParsePostDaemonLeaveResponse(rsp *http.Response) (*PostDaemonLeaveResponse, error) {
+	bodyBytes, err := io.ReadAll(rsp.Body)
+	defer func() { _ = rsp.Body.Close() }()
+	if err != nil {
+		return nil, err
+	}
+
+	response := &PostDaemonLeaveResponse{
+		Body:         bodyBytes,
+		HTTPResponse: rsp,
+	}
+
+	switch {
+	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
+		var dest N400
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
 			return nil, err
 		}
-		response.JSON503 = &dest
+		response.JSON400 = &dest
 
 	}
 
 	return response, nil
 }
 
-// ParsePostClusterActionAbortResponse parses an HTTP response from a PostClusterActionAbortWithResponse call
-func ParsePostClusterActionAbortResponse(rsp *http.Response) (*PostClusterActionAbortResponse, error) {
+// ParsePostDaemonLogsControlResponse parses an HTTP response from a PostDaemonLogsControlWithResponse call
+func ParsePostDaemonLogsControlResponse(rsp *http.Response) (*PostDaemonLogsControlResponse, error) {
 	bodyBytes, err := io.ReadAll(rsp.Body)
 	defer func() { _ = rsp.Body.Close() }()
 	if err != nil {
 		return nil, err
 	}
 
-	response := &PostClusterActionAbortResponse{
+	response := &PostDaemonLogsControlResponse{
 		Body:         bodyBytes,
 		HTTPResponse: rsp,
 	}
 
 	switch {
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
-		var dest OrchestrationQueued
+		var dest N200
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
 			return nil, err
 		}
@@ -12146,19 +13262,52 @@ func ParsePostClusterActionAbortResponse(rsp *http.Response) (*PostClusterAction
 		}
 		response.JSON403 = &dest
 
-	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 408:
-		var dest N408
+	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 500:
+		var dest N500
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
 			return nil, err
 		}
-		response.JSON408 = &dest
+		response.JSON500 = &dest
 
-	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 409:
-		var dest N409
+	}
+
+	return response, nil
+}
+
+// ParseGetDaemonStatusResponse parses an HTTP response from a GetDaemonStatusWithResponse call
+func ParseGetDaemonStatusResponse(rsp *http.Response) (*GetDaemonStatusResponse, error) {
+	bodyBytes, err := io.ReadAll(rsp.Body)
+	defer func() { _ = rsp.Body.Close() }()
+	if err != nil {
+		return nil, err
+	}
+
+	response := &GetDaemonStatusResponse{
+		Body:         bodyBytes,
+		HTTPResponse: rsp,
+	}
+
+	switch {
+	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
+		var dest DaemonStatus
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
 			return nil, err
 		}
-		response.JSON409 = &dest
+		response.JSON200 = &dest
+
+	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401:
+		var dest N401
+		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
+			return nil, err
+		}
+		response.JSON401 = &dest
+
+	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 403:
+		var dest N403
+		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
+			return nil, err
+		}
+		response.JSON403 = &dest
 
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 500:
 		var dest N500
@@ -12172,22 +13321,22 @@ func ParsePostClusterActionAbortResponse(rsp *http.Response) (*PostClusterAction
 	return response, nil
 }
 
-// ParsePostClusterActionFreezeResponse parses an HTTP response from a PostClusterActionFreezeWithResponse call
-func ParsePostClusterActionFreezeResponse(rsp *http.Response) (*PostClusterActionFreezeResponse, error) {
+// ParsePostDaemonSubActionResponse parses an HTTP response from a PostDaemonSubActionWithResponse call
+func ParsePostDaemonSubActionResponse(rsp *http.Response) (*PostDaemonSubActionResponse, error) {
 	bodyBytes, err := io.ReadAll(rsp.Body)
 	defer func() { _ = rsp.Body.Close() }()
 	if err != nil {
 		return nil, err
 	}
 
-	response := &PostClusterActionFreezeResponse{
+	response := &PostDaemonSubActionResponse{
 		Body:         bodyBytes,
 		HTTPResponse: rsp,
 	}
 
 	switch {
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
-		var dest OrchestrationQueued
+		var dest N200
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
 			return nil, err
 		}
@@ -12214,19 +13363,52 @@ func ParsePostClusterActionFreezeResponse(rsp *http.Response) (*PostClusterActio
 		}
 		response.JSON403 = &dest
 
-	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 408:
-		var dest N408
+	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 500:
+		var dest N500
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
 			return nil, err
 		}
-		response.JSON408 = &dest
+		response.JSON500 = &dest
 
-	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 409:
-		var dest N409
+	}
+
+	return response, nil
+}
+
+// ParseGetDNSDumpResponse parses an HTTP response from a GetDNSDumpWithResponse call
+func ParseGetDNSDumpResponse(rsp *http.Response) (*GetDNSDumpResponse, error) {
+	bodyBytes, err := io.ReadAll(rsp.Body)
+	defer func() { _ = rsp.Body.Close() }()
+	if err != nil {
+		return nil, err
+	}
+
+	response := &GetDNSDumpResponse{
+		Body:         bodyBytes,
+		HTTPResponse: rsp,
+	}
+
+	switch {
+	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
+		var dest DNSZone
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
 			return nil, err
 		}
-		response.JSON409 = &dest
+		response.JSON200 = &dest
+
+	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401:
+		var dest N401
+		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
+			return nil, err
+		}
+		response.JSON401 = &dest
+
+	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 403:
+		var dest N403
+		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
+			return nil, err
+		}
+		response.JSON403 = &dest
 
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 500:
 		var dest N500
@@ -12240,22 +13422,22 @@ func ParsePostClusterActionFreezeResponse(rsp *http.Response) (*PostClusterActio
 	return response, nil
 }
 
-// ParsePostClusterActionUnfreezeResponse parses an HTTP response from a PostClusterActionUnfreezeWithResponse call
-func ParsePostClusterActionUnfreezeResponse(rsp *http.Response) (*PostClusterActionUnfreezeResponse, error) {
+// ParseGetInstancesResponse parses an HTTP response from a GetInstancesWithResponse call
+func ParseGetInstancesResponse(rsp *http.Response) (*GetInstancesResponse, error) {
 	bodyBytes, err := io.ReadAll(rsp.Body)
 	defer func() { _ = rsp.Body.Close() }()
 	if err != nil {
 		return nil, err
 	}
 
-	response := &PostClusterActionUnfreezeResponse{
+	response := &GetInstancesResponse{
 		Body:         bodyBytes,
 		HTTPResponse: rsp,
 	}
 
 	switch {
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
-		var dest OrchestrationQueued
+		var dest InstanceList
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
 			return nil, err
 		}
@@ -12282,19 +13464,52 @@ func ParsePostClusterActionUnfreezeResponse(rsp *http.Response) (*PostClusterAct
 		}
 		response.JSON403 = &dest
 
-	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 408:
-		var dest N408
+	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 500:
+		var dest N500
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
 			return nil, err
 		}
-		response.JSON408 = &dest
+		response.JSON500 = &dest
 
-	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 409:
-		var dest N409
+	}
+
+	return response, nil
+}
+
+// ParsePostInstanceProgressResponse parses an HTTP response from a PostInstanceProgressWithResponse call
+func ParsePostInstanceProgressResponse(rsp *http.Response) (*PostInstanceProgressResponse, error) {
+	bodyBytes, err := io.ReadAll(rsp.Body)
+	defer func() { _ = rsp.Body.Close() }()
+	if err != nil {
+		return nil, err
+	}
+
+	response := &PostInstanceProgressResponse{
+		Body:         bodyBytes,
+		HTTPResponse: rsp,
+	}
+
+	switch {
+	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
+		var dest N400
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
 			return nil, err
 		}
-		response.JSON409 = &dest
+		response.JSON400 = &dest
+
+	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401:
+		var dest N401
+		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
+			return nil, err
+		}
+		response.JSON401 = &dest
+
+	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 403:
+		var dest N403
+		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
+			return nil, err
+		}
+		response.JSON403 = &dest
 
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 500:
 		var dest N500
@@ -12308,15 +13523,15 @@ func ParsePostClusterActionUnfreezeResponse(rsp *http.Response) (*PostClusterAct
 	return response, nil
 }
 
-// ParsePostDaemonJoinResponse parses an HTTP response from a PostDaemonJoinWithResponse call
-func ParsePostDaemonJoinResponse(rsp *http.Response) (*PostDaemonJoinResponse, error) {
+// ParsePostInstanceStatusResponse parses an HTTP response from a PostInstanceStatusWithResponse call
+func ParsePostInstanceStatusResponse(rsp *http.Response) (*PostInstanceStatusResponse, error) {
 	bodyBytes, err := io.ReadAll(rsp.Body)
 	defer func() { _ = rsp.Body.Close() }()
 	if err != nil {
 		return nil, err
 	}
 
-	response := &PostDaemonJoinResponse{
+	response := &PostInstanceStatusResponse{
 		Body:         bodyBytes,
 		HTTPResponse: rsp,
 	}
@@ -12355,60 +13570,27 @@ func ParsePostDaemonJoinResponse(rsp *http.Response) (*PostDaemonJoinResponse, e
 	return response, nil
 }
 
-// ParsePostDaemonLeaveResponse parses an HTTP response from a PostDaemonLeaveWithResponse call
-func ParsePostDaemonLeaveResponse(rsp *http.Response) (*PostDaemonLeaveResponse, error) {
-	bodyBytes, err := io.ReadAll(rsp.Body)
-	defer func() { _ = rsp.Body.Close() }()
-	if err != nil {
-		return nil, err
-	}
-
-	response := &PostDaemonLeaveResponse{
-		Body:         bodyBytes,
-		HTTPResponse: rsp,
-	}
-
-	switch {
-	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
-		var dest N400
-		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
-			return nil, err
-		}
-		response.JSON400 = &dest
-
-	}
-
-	return response, nil
-}
-
-// ParsePostDaemonLogsControlResponse parses an HTTP response from a PostDaemonLogsControlWithResponse call
-func ParsePostDaemonLogsControlResponse(rsp *http.Response) (*PostDaemonLogsControlResponse, error) {
+// ParseGetNetworksResponse parses an HTTP response from a GetNetworksWithResponse call
+func ParseGetNetworksResponse(rsp *http.Response) (*GetNetworksResponse, error) {
 	bodyBytes, err := io.ReadAll(rsp.Body)
 	defer func() { _ = rsp.Body.Close() }()
 	if err != nil {
 		return nil, err
 	}
 
-	response := &PostDaemonLogsControlResponse{
+	response := &GetNetworksResponse{
 		Body:         bodyBytes,
 		HTTPResponse: rsp,
 	}
 
 	switch {
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
-		var dest N200
+		var dest NetworkList
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
 			return nil, err
 		}
 		response.JSON200 = &dest
 
-	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
-		var dest N400
-		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
-			return nil, err
-		}
-		response.JSON400 = &dest
-
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401:
 		var dest N401
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
@@ -12435,22 +13617,22 @@ func ParsePostDaemonLogsControlResponse(rsp *http.Response) (*PostDaemonLogsCont
 	return response, nil
 }
 
-// ParseGetDaemonStatusResponse parses an HTTP response from a GetDaemonStatusWithResponse call
-func ParseGetDaemonStatusResponse(rsp *http.Response) (*GetDaemonStatusResponse, error) {
+// ParseGetNetworkIPResponse parses an HTTP response from a GetNetworkIPWithResponse call
+func ParseGetNetworkIPResponse(rsp *http.Response) (*GetNetworkIPResponse, error) {
 	bodyBytes, err := io.ReadAll(rsp.Body)
 	defer func() { _ = rsp.Body.Close() }()
 	if err != nil {
 		return nil, err
 	}
 
-	response := &GetDaemonStatusResponse{
+	response := &GetNetworkIPResponse{
 		Body:         bodyBytes,
 		HTTPResponse: rsp,
 	}
 
 	switch {
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
-		var dest DaemonStatus
+		var dest NetworkIPList
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
 			return nil, err
 		}
@@ -12482,22 +13664,22 @@ func ParseGetDaemonStatusResponse(rsp *http.Response) (*GetDaemonStatusResponse,
 	return response, nil
 }
 
-// ParsePostDaemonSubActionResponse parses an HTTP response from a PostDaemonSubActionWithResponse call
-func ParsePostDaemonSubActionResponse(rsp *http.Response) (*PostDaemonSubActionResponse, error) {
+// ParseGetNodesResponse parses an HTTP response from a GetNodesWithResponse call
+func ParseGetNodesResponse(rsp *http.Response) (*GetNodesResponse, error) {
 	bodyBytes, err := io.ReadAll(rsp.Body)
 	defer func() { _ = rsp.Body.Close() }()
 	if err != nil {
 		return nil, err
 	}
 
-	response := &PostDaemonSubActionResponse{
+	response := &GetNodesResponse{
 		Body:         bodyBytes,
 		HTTPResponse: rsp,
 	}
 
 	switch {
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
-		var dest N200
+		var dest NodeList
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
 			return nil, err
 		}
@@ -12536,27 +13718,34 @@ func ParsePostDaemonSubActionResponse(rsp *http.Response) (*PostDaemonSubActionR
 	return response, nil
 }
 
-// ParseGetDNSDumpResponse parses an HTTP response from a GetDNSDumpWithResponse call
-func ParseGetDNSDumpResponse(rsp *http.Response) (*GetDNSDumpResponse, error) {
+// ParsePostNodeClearResponse parses an HTTP response from a PostNodeClearWithResponse call
+func ParsePostNodeClearResponse(rsp *http.Response) (*PostNodeClearResponse, error) {
 	bodyBytes, err := io.ReadAll(rsp.Body)
 	defer func() { _ = rsp.Body.Close() }()
 	if err != nil {
 		return nil, err
 	}
 
-	response := &GetDNSDumpResponse{
+	response := &PostNodeClearResponse{
 		Body:         bodyBytes,
 		HTTPResponse: rsp,
 	}
 
 	switch {
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
-		var dest DNSZone
+		var dest N200
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
 			return nil, err
 		}
 		response.JSON200 = &dest
 
+	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
+		var dest N400
+		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
+			return nil, err
+		}
+		response.JSON400 = &dest
+
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401:
 		var dest N401
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
@@ -12583,34 +13772,27 @@ func ParseGetDNSDumpResponse(rsp *http.Response) (*GetDNSDumpResponse, error) {
 	return response, nil
 }
 
-// ParseGetInstancesResponse parses an HTTP response from a GetInstancesWithResponse call
-func ParseGetInstancesResponse(rsp *http.Response) (*GetInstancesResponse, error) {
+// ParseGetNodesInfoResponse parses an HTTP response from a GetNodesInfoWithResponse call
+func ParseGetNodesInfoResponse(rsp *http.Response) (*GetNodesInfoResponse, error) {
 	bodyBytes, err := io.ReadAll(rsp.Body)
 	defer func() { _ = rsp.Body.Close() }()
 	if err != nil {
 		return nil, err
 	}
 
-	response := &GetInstancesResponse{
+	response := &GetNodesInfoResponse{
 		Body:         bodyBytes,
 		HTTPResponse: rsp,
 	}
 
 	switch {
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
-		var dest InstanceList
+		var dest NodesInfo
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
 			return nil, err
 		}
 		response.JSON200 = &dest
 
-	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
-		var dest N400
-		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
-			return nil, err
-		}
-		response.JSON400 = &dest
-
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401:
 		var dest N401
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
@@ -12637,20 +13819,27 @@ func ParseGetInstancesResponse(rsp *http.Response) (*GetInstancesResponse, error
 	return response, nil
 }
 
-// ParsePostInstanceProgressResponse parses an HTTP response from a PostInstanceProgressWithResponse call
-func ParsePostInstanceProgressResponse(rsp *http.Response) (*PostInstanceProgressResponse, error) {
+// ParsePostPeerActionAbortResponse parses an HTTP response from a PostPeerActionAbortWithResponse call
+func ParsePostPeerActionAbortResponse(rsp *http.Response) (*PostPeerActionAbortResponse, error) {
 	bodyBytes, err := io.ReadAll(rsp.Body)
 	defer func() { _ = rsp.Body.Close() }()
 	if err != nil {
 		return nil, err
 	}
 
-	response := &PostInstanceProgressResponse{
+	response := &PostPeerActionAbortResponse{
 		Body:         bodyBytes,
 		HTTPResponse: rsp,
 	}
 
 	switch {
+	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
+		var dest OrchestrationQueued
+		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
+			return nil, err
+		}
+		response.JSON200 = &dest
+
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
 		var dest N400
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
@@ -12672,6 +13861,20 @@ func ParsePostInstanceProgressResponse(rsp *http.Response) (*PostInstanceProgres
 		}
 		response.JSON403 = &dest
 
+	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 408:
+		var dest N408
+		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
+			return nil, err
+		}
+		response.JSON408 = &dest
+
+	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 409:
+		var dest N409
+		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
+			return nil, err
+		}
+		response.JSON409 = &dest
+
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 500:
 		var dest N500
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
@@ -12684,20 +13887,27 @@ func ParsePostInstanceProgressResponse(rsp *http.Response) (*PostInstanceProgres
 	return response, nil
 }
 
-// ParsePostInstanceStatusResponse parses an HTTP response from a PostInstanceStatusWithResponse call
-func ParsePostInstanceStatusResponse(rsp *http.Response) (*PostInstanceStatusResponse, error) {
+// ParsePostPeerActionDrainResponse parses an HTTP response from a PostPeerActionDrainWithResponse call
+func ParsePostPeerActionDrainResponse(rsp *http.Response) (*PostPeerActionDrainResponse, error) {
 	bodyBytes, err := io.ReadAll(rsp.Body)
 	defer func() { _ = rsp.Body.Close() }()
 	if err != nil {
 		return nil, err
 	}
 
-	response := &PostInstanceStatusResponse{
+	response := &PostPeerActionDrainResponse{
 		Body:         bodyBytes,
 		HTTPResponse: rsp,
 	}
 
 	switch {
+	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
+		var dest OrchestrationQueued
+		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
+			return nil, err
+		}
+		response.JSON200 = &dest
+
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
 		var dest N400
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
@@ -12719,6 +13929,20 @@ func ParsePostInstanceStatusResponse(rsp *http.Response) (*PostInstanceStatusRes
 		}
 		response.JSON403 = &dest
 
+	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 408:
+		var dest N408
+		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
+			return nil, err
+		}
+		response.JSON408 = &dest
+
+	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 409:
+		var dest N409
+		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
+			return nil, err
+		}
+		response.JSON409 = &dest
+
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 500:
 		var dest N500
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
@@ -12731,27 +13955,34 @@ func ParsePostInstanceStatusResponse(rsp *http.Response) (*PostInstanceStatusRes
 	return response, nil
 }
 
-// ParseGetNetworksResponse parses an HTTP response from a GetNetworksWithResponse call
-func ParseGetNetworksResponse(rsp *http.Response) (*GetNetworksResponse, error) {
+// ParsePostPeerActionFreezeResponse parses an HTTP response from a PostPeerActionFreezeWithResponse call
+func ParsePostPeerActionFreezeResponse(rsp *http.Response) (*PostPeerActionFreezeResponse, error) {
 	bodyBytes, err := io.ReadAll(rsp.Body)
 	defer func() { _ = rsp.Body.Close() }()
 	if err != nil {
 		return nil, err
 	}
 
-	response := &GetNetworksResponse{
+	response := &PostPeerActionFreezeResponse{
 		Body:         bodyBytes,
 		HTTPResponse: rsp,
 	}
 
 	switch {
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
-		var dest NetworkList
+		var dest NodeActionAccepted
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
 			return nil, err
 		}
 		response.JSON200 = &dest
 
+	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
+		var dest N400
+		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
+			return nil, err
+		}
+		response.JSON400 = &dest
+
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401:
 		var dest N401
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
@@ -12778,22 +14009,22 @@ func ParseGetNetworksResponse(rsp *http.Response) (*GetNetworksResponse, error)
 	return response, nil
 }
 
-// ParseGetNetworkIPResponse parses an HTTP response from a GetNetworkIPWithResponse call
-func ParseGetNetworkIPResponse(rsp *http.Response) (*GetNetworkIPResponse, error) {
+// ParsePostNodeActionPushAssetResponse parses an HTTP response from a PostNodeActionPushAssetWithResponse call
+func ParsePostNodeActionPushAssetResponse(rsp *http.Response) (*PostNodeActionPushAssetResponse, error) {
 	bodyBytes, err := io.ReadAll(rsp.Body)
 	defer func() { _ = rsp.Body.Close() }()
 	if err != nil {
 		return nil, err
 	}
 
-	response := &GetNetworkIPResponse{
+	response := &PostNodeActionPushAssetResponse{
 		Body:         bodyBytes,
 		HTTPResponse: rsp,
 	}
 
 	switch {
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
-		var dest NetworkIPList
+		var dest NodeActionAccepted
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
 			return nil, err
 		}
@@ -12825,34 +14056,27 @@ func ParseGetNetworkIPResponse(rsp *http.Response) (*GetNetworkIPResponse, error
 	return response, nil
 }
 
-// ParseGetNodesResponse parses an HTTP response from a GetNodesWithResponse call
-func ParseGetNodesResponse(rsp *http.Response) (*GetNodesResponse, error) {
+// ParsePostNodeActionPushDiskResponse parses an HTTP response from a PostNodeActionPushDiskWithResponse call
+func ParsePostNodeActionPushDiskResponse(rsp *http.Response) (*PostNodeActionPushDiskResponse, error) {
 	bodyBytes, err := io.ReadAll(rsp.Body)
 	defer func() { _ = rsp.Body.Close() }()
 	if err != nil {
 		return nil, err
 	}
 
-	response := &GetNodesResponse{
+	response := &PostNodeActionPushDiskResponse{
 		Body:         bodyBytes,
 		HTTPResponse: rsp,
 	}
 
 	switch {
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
-		var dest NodeList
+		var dest NodeActionAccepted
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
 			return nil, err
 		}
 		response.JSON200 = &dest
 
-	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
-		var dest N400
-		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
-			return nil, err
-		}
-		response.JSON400 = &dest
-
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401:
 		var dest N401
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
@@ -12879,34 +14103,27 @@ func ParseGetNodesResponse(rsp *http.Response) (*GetNodesResponse, error) {
 	return response, nil
 }
 
-// ParsePostNodeClearResponse parses an HTTP response from a PostNodeClearWithResponse call
-func ParsePostNodeClearResponse(rsp *http.Response) (*PostNodeClearResponse, error) {
+// ParsePostNodeActionPushPatchResponse parses an HTTP response from a PostNodeActionPushPatchWithResponse call
+func ParsePostNodeActionPushPatchResponse(rsp *http.Response) (*PostNodeActionPushPatchResponse, error) {
 	bodyBytes, err := io.ReadAll(rsp.Body)
 	defer func() { _ = rsp.Body.Close() }()
 	if err != nil {
 		return nil, err
 	}
 
-	response := &PostNodeClearResponse{
+	response := &PostNodeActionPushPatchResponse{
 		Body:         bodyBytes,
 		HTTPResponse: rsp,
 	}
 
 	switch {
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
-		var dest N200
+		var dest NodeActionAccepted
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
 			return nil, err
 		}
 		response.JSON200 = &dest
 
-	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
-		var dest N400
-		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
-			return nil, err
-		}
-		response.JSON400 = &dest
-
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401:
 		var dest N401
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
@@ -12933,22 +14150,22 @@ func ParsePostNodeClearResponse(rsp *http.Response) (*PostNodeClearResponse, err
 	return response, nil
 }
 
-// ParseGetNodesInfoResponse parses an HTTP response from a GetNodesInfoWithResponse call
-func ParseGetNodesInfoResponse(rsp *http.Response) (*GetNodesInfoResponse, error) {
+// ParsePostNodeActionPushPkgResponse parses an HTTP response from a PostNodeActionPushPkgWithResponse call
+func ParsePostNodeActionPushPkgResponse(rsp *http.Response) (*PostNodeActionPushPkgResponse, error) {
 	bodyBytes, err := io.ReadAll(rsp.Body)
 	defer func() { _ = rsp.Body.Close() }()
 	if err != nil {
 		return nil, err
 	}
 
-	response := &GetNodesInfoResponse{
+	response := &PostNodeActionPushPkgResponse{
 		Body:         bodyBytes,
 		HTTPResponse: rsp,
 	}
 
 	switch {
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
-		var dest NodesInfo
+		var dest NodeActionAccepted
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
 			return nil, err
 		}
@@ -12980,34 +14197,27 @@ func ParseGetNodesInfoResponse(rsp *http.Response) (*GetNodesInfoResponse, error
 	return response, nil
 }
 
-// ParsePostPeerActionAbortResponse parses an HTTP response from a PostPeerActionAbortWithResponse call
-func ParsePostPeerActionAbortResponse(rsp *http.Response) (*PostPeerActionAbortResponse, error) {
+// ParsePostNodeActionScanCapabilitiesResponse parses an HTTP response from a PostNodeActionScanCapabilitiesWithResponse call
+func ParsePostNodeActionScanCapabilitiesResponse(rsp *http.Response) (*PostNodeActionScanCapabilitiesResponse, error) {
 	bodyBytes, err := io.ReadAll(rsp.Body)
 	defer func() { _ = rsp.Body.Close() }()
 	if err != nil {
 		return nil, err
 	}
 
-	response := &PostPeerActionAbortResponse{
+	response := &PostNodeActionScanCapabilitiesResponse{
 		Body:         bodyBytes,
 		HTTPResponse: rsp,
 	}
 
 	switch {
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
-		var dest OrchestrationQueued
+		var dest NodeActionAccepted
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
 			return nil, err
 		}
 		response.JSON200 = &dest
 
-	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
-		var dest N400
-		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
-			return nil, err
-		}
-		response.JSON400 = &dest
-
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401:
 		var dest N401
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
@@ -13022,20 +14232,6 @@ func ParsePostPeerActionAbortResponse(rsp *http.Response) (*PostPeerActionAbortR
 		}
 		response.JSON403 = &dest
 
-	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 408:
-		var dest N408
-		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
-			return nil, err
-		}
-		response.JSON408 = &dest
-
-	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 409:
-		var dest N409
-		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
-			return nil, err
-		}
-		response.JSON409 = &dest
-
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 500:
 		var dest N500
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
@@ -13048,22 +14244,22 @@ func ParsePostPeerActionAbortResponse(rsp *http.Response) (*PostPeerActionAbortR
 	return response, nil
 }
 
-// ParsePostPeerActionDrainResponse parses an HTTP response from a PostPeerActionDrainWithResponse call
-func ParsePostPeerActionDrainResponse(rsp *http.Response) (*PostPeerActionDrainResponse, error) {
+// ParsePostNodeActionSysreportResponse parses an HTTP response from a PostNodeActionSysreportWithResponse call
+func ParsePostNodeActionSysreportResponse(rsp *http.Response) (*PostNodeActionSysreportResponse, error) {
 	bodyBytes, err := io.ReadAll(rsp.Body)
 	defer func() { _ = rsp.Body.Close() }()
 	if err != nil {
 		return nil, err
 	}
 
-	response := &PostPeerActionDrainResponse{
+	response := &PostNodeActionSysreportResponse{
 		Body:         bodyBytes,
 		HTTPResponse: rsp,
 	}
 
 	switch {
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
-		var dest OrchestrationQueued
+		var dest NodeActionAccepted
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
 			return nil, err
 		}
@@ -13075,34 +14271,20 @@ func ParsePostPeerActionDrainResponse(rsp *http.Response) (*PostPeerActionDrainR
 			return nil, err
 		}
 		response.JSON400 = &dest
-
-	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401:
-		var dest N401
-		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
-			return nil, err
-		}
-		response.JSON401 = &dest
-
-	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 403:
-		var dest N403
-		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
-			return nil, err
-		}
-		response.JSON403 = &dest
-
-	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 408:
-		var dest N408
+
+	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401:
+		var dest N401
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
 			return nil, err
 		}
-		response.JSON408 = &dest
+		response.JSON401 = &dest
 
-	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 409:
-		var dest N409
+	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 403:
+		var dest N403
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
 			return nil, err
 		}
-		response.JSON409 = &dest
+		response.JSON403 = &dest
 
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 500:
 		var dest N500
@@ -13116,15 +14298,15 @@ func ParsePostPeerActionDrainResponse(rsp *http.Response) (*PostPeerActionDrainR
 	return response, nil
 }
 
-// ParsePostPeerActionFreezeResponse parses an HTTP response from a PostPeerActionFreezeWithResponse call
-func ParsePostPeerActionFreezeResponse(rsp *http.Response) (*PostPeerActionFreezeResponse, error) {
+// ParsePostPeerActionUnfreezeResponse parses an HTTP response from a PostPeerActionUnfreezeWithResponse call
+func ParsePostPeerActionUnfreezeResponse(rsp *http.Response) (*PostPeerActionUnfreezeResponse, error) {
 	bodyBytes, err := io.ReadAll(rsp.Body)
 	defer func() { _ = rsp.Body.Close() }()
 	if err != nil {
 		return nil, err
 	}
 
-	response := &PostPeerActionFreezeResponse{
+	response := &PostPeerActionUnfreezeResponse{
 		Body:         bodyBytes,
 		HTTPResponse: rsp,
 	}
@@ -13170,27 +14352,34 @@ func ParsePostPeerActionFreezeResponse(rsp *http.Response) (*PostPeerActionFreez
 	return response, nil
 }
 
-// ParsePostNodeActionPushAssetResponse parses an HTTP response from a PostNodeActionPushAssetWithResponse call
-func ParsePostNodeActionPushAssetResponse(rsp *http.Response) (*PostNodeActionPushAssetResponse, error) {
+// ParseGetNodeCapabilitiesResponse parses an HTTP response from a GetNodeCapabilitiesWithResponse call
+func ParseGetNodeCapabilitiesResponse(rsp *http.Response) (*GetNodeCapabilitiesResponse, error) {
 	bodyBytes, err := io.ReadAll(rsp.Body)
 	defer func() { _ = rsp.Body.Close() }()
 	if err != nil {
 		return nil, err
 	}
 
-	response := &PostNodeActionPushAssetResponse{
+	response := &GetNodeCapabilitiesResponse{
 		Body:         bodyBytes,
 		HTTPResponse: rsp,
 	}
 
 	switch {
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
-		var dest NodeActionAccepted
+		var dest CapabilityList
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
 			return nil, err
 		}
 		response.JSON200 = &dest
 
+	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
+		var dest N400
+		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
+			return nil, err
+		}
+		response.JSON400 = &dest
+
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401:
 		var dest N401
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
@@ -13217,27 +14406,34 @@ func ParsePostNodeActionPushAssetResponse(rsp *http.Response) (*PostNodeActionPu
 	return response, nil
 }
 
-// ParsePostNodeActionPushDiskResponse parses an HTTP response from a PostNodeActionPushDiskWithResponse call
-func ParsePostNodeActionPushDiskResponse(rsp *http.Response) (*PostNodeActionPushDiskResponse, error) {
+// ParseGetNodeConfigResponse parses an HTTP response from a GetNodeConfigWithResponse call
+func ParseGetNodeConfigResponse(rsp *http.Response) (*GetNodeConfigResponse, error) {
 	bodyBytes, err := io.ReadAll(rsp.Body)
 	defer func() { _ = rsp.Body.Close() }()
 	if err != nil {
 		return nil, err
 	}
 
-	response := &PostNodeActionPushDiskResponse{
+	response := &GetNodeConfigResponse{
 		Body:         bodyBytes,
 		HTTPResponse: rsp,
 	}
 
 	switch {
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
-		var dest NodeActionAccepted
+		var dest ObjectConfig
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
 			return nil, err
 		}
 		response.JSON200 = &dest
 
+	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
+		var dest N400
+		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
+			return nil, err
+		}
+		response.JSON400 = &dest
+
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401:
 		var dest N401
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
@@ -13264,27 +14460,34 @@ func ParsePostNodeActionPushDiskResponse(rsp *http.Response) (*PostNodeActionPus
 	return response, nil
 }
 
-// ParsePostNodeActionPushPatchResponse parses an HTTP response from a PostNodeActionPushPatchWithResponse call
-func ParsePostNodeActionPushPatchResponse(rsp *http.Response) (*PostNodeActionPushPatchResponse, error) {
+// ParseGetNodeConfigGetResponse parses an HTTP response from a GetNodeConfigGetWithResponse call
+func ParseGetNodeConfigGetResponse(rsp *http.Response) (*GetNodeConfigGetResponse, error) {
 	bodyBytes, err := io.ReadAll(rsp.Body)
 	defer func() { _ = rsp.Body.Close() }()
 	if err != nil {
 		return nil, err
 	}
 
-	response := &PostNodeActionPushPatchResponse{
+	response := &GetNodeConfigGetResponse{
 		Body:         bodyBytes,
 		HTTPResponse: rsp,
 	}
 
 	switch {
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
-		var dest NodeActionAccepted
+		var dest KeywordList
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
 			return nil, err
 		}
 		response.JSON200 = &dest
 
+	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
+		var dest N400
+		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
+			return nil, err
+		}
+		response.JSON400 = &dest
+
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401:
 		var dest N401
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
@@ -13311,27 +14514,34 @@ func ParsePostNodeActionPushPatchResponse(rsp *http.Response) (*PostNodeActionPu
 	return response, nil
 }
 
-// ParsePostNodeActionPushPkgResponse parses an HTTP response from a PostNodeActionPushPkgWithResponse call
-func ParsePostNodeActionPushPkgResponse(rsp *http.Response) (*PostNodeActionPushPkgResponse, error) {
+// ParsePostNodeConfigUpdateResponse parses an HTTP response from a PostNodeConfigUpdateWithResponse call
+func ParsePostNodeConfigUpdateResponse(rsp *http.Response) (*PostNodeConfigUpdateResponse, error) {
 	bodyBytes, err := io.ReadAll(rsp.Body)
 	defer func() { _ = rsp.Body.Close() }()
 	if err != nil {
 		return nil, err
 	}
 
-	response := &PostNodeActionPushPkgResponse{
+	response := &PostNodeConfigUpdateResponse{
 		Body:         bodyBytes,
 		HTTPResponse: rsp,
 	}
 
 	switch {
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
-		var dest NodeActionAccepted
+		var dest Committed
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
 			return nil, err
 		}
 		response.JSON200 = &dest
 
+	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
+		var dest N400
+		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
+			return nil, err
+		}
+		response.JSON400 = &dest
+
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401:
 		var dest N401
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
@@ -13358,27 +14568,34 @@ func ParsePostNodeActionPushPkgResponse(rsp *http.Response) (*PostNodeActionPush
 	return response, nil
 }
 
-// ParsePostNodeActionScanCapabilitiesResponse parses an HTTP response from a PostNodeActionScanCapabilitiesWithResponse call
-func ParsePostNodeActionScanCapabilitiesResponse(rsp *http.Response) (*PostNodeActionScanCapabilitiesResponse, error) {
+// ParsePostDaemonRestartResponse parses an HTTP response from a PostDaemonRestartWithResponse call
+func ParsePostDaemonRestartResponse(rsp *http.Response) (*PostDaemonRestartResponse, error) {
 	bodyBytes, err := io.ReadAll(rsp.Body)
 	defer func() { _ = rsp.Body.Close() }()
 	if err != nil {
 		return nil, err
 	}
 
-	response := &PostNodeActionScanCapabilitiesResponse{
+	response := &PostDaemonRestartResponse{
 		Body:         bodyBytes,
 		HTTPResponse: rsp,
 	}
 
 	switch {
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
-		var dest NodeActionAccepted
+		var dest N200
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
 			return nil, err
 		}
 		response.JSON200 = &dest
 
+	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
+		var dest N400
+		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
+			return nil, err
+		}
+		response.JSON400 = &dest
+
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401:
 		var dest N401
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
@@ -13405,22 +14622,22 @@ func ParsePostNodeActionScanCapabilitiesResponse(rsp *http.Response) (*PostNodeA
 	return response, nil
 }
 
-// ParsePostNodeActionSysreportResponse parses an HTTP response from a PostNodeActionSysreportWithResponse call
-func ParsePostNodeActionSysreportResponse(rsp *http.Response) (*PostNodeActionSysreportResponse, error) {
+// ParsePostDaemonShutdownResponse parses an HTTP response from a PostDaemonShutdownWithResponse call
+func ParsePostDaemonShutdownResponse(rsp *http.Response) (*PostDaemonShutdownResponse, error) {
 	bodyBytes, err := io.ReadAll(rsp.Body)
 	defer func() { _ = rsp.Body.Close() }()
 	if err != nil {
 		return nil, err
 	}
 
-	response := &PostNodeActionSysreportResponse{
+	response := &PostDaemonShutdownResponse{
 		Body:         bodyBytes,
 		HTTPResponse: rsp,
 	}
 
 	switch {
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
-		var dest NodeActionAccepted
+		var dest DaemonPid
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
 			return nil, err
 		}
@@ -13459,22 +14676,22 @@ func ParsePostNodeActionSysreportResponse(rsp *http.Response) (*PostNodeActionSy
 	return response, nil
 }
 
-// ParsePostPeerActionUnfreezeResponse parses an HTTP response from a PostPeerActionUnfreezeWithResponse call
-func ParsePostPeerActionUnfreezeResponse(rsp *http.Response) (*PostPeerActionUnfreezeResponse, error) {
+// ParsePostDaemonStopResponse parses an HTTP response from a PostDaemonStopWithResponse call
+func ParsePostDaemonStopResponse(rsp *http.Response) (*PostDaemonStopResponse, error) {
 	bodyBytes, err := io.ReadAll(rsp.Body)
 	defer func() { _ = rsp.Body.Close() }()
 	if err != nil {
 		return nil, err
 	}
 
-	response := &PostPeerActionUnfreezeResponse{
+	response := &PostDaemonStopResponse{
 		Body:         bodyBytes,
 		HTTPResponse: rsp,
 	}
 
 	switch {
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
-		var dest NodeActionAccepted
+		var dest DaemonPid
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
 			return nil, err
 		}
@@ -13513,27 +14730,20 @@ func ParsePostPeerActionUnfreezeResponse(rsp *http.Response) (*PostPeerActionUnf
 	return response, nil
 }
 
-// ParseGetNodeCapabilitiesResponse parses an HTTP response from a GetNodeCapabilitiesWithResponse call
-func ParseGetNodeCapabilitiesResponse(rsp *http.Response) (*GetNodeCapabilitiesResponse, error) {
+// ParseGetDaemonEventsResponse parses an HTTP response from a GetDaemonEventsWithResponse call
+func ParseGetDaemonEventsResponse(rsp *http.Response) (*GetDaemonEventsResponse, error) {
 	bodyBytes, err := io.ReadAll(rsp.Body)
 	defer func() { _ = rsp.Body.Close() }()
 	if err != nil {
 		return nil, err
 	}
 
-	response := &GetNodeCapabilitiesResponse{
+	response := &GetDaemonEventsResponse{
 		Body:         bodyBytes,
 		HTTPResponse: rsp,
 	}
 
 	switch {
-	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
-		var dest CapabilityList
-		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
-			return nil, err
-		}
-		response.JSON200 = &dest
-
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
 		var dest N400
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
@@ -13567,22 +14777,22 @@ func ParseGetNodeCapabilitiesResponse(rsp *http.Response) (*GetNodeCapabilitiesR
 	return response, nil
 }
 
-// ParseGetNodeConfigResponse parses an HTTP response from a GetNodeConfigWithResponse call
-func ParseGetNodeConfigResponse(rsp *http.Response) (*GetNodeConfigResponse, error) {
+// ParseGetNodeDRBDAllocationResponse parses an HTTP response from a GetNodeDRBDAllocationWithResponse call
+func ParseGetNodeDRBDAllocationResponse(rsp *http.Response) (*GetNodeDRBDAllocationResponse, error) {
 	bodyBytes, err := io.ReadAll(rsp.Body)
 	defer func() { _ = rsp.Body.Close() }()
 	if err != nil {
 		return nil, err
 	}
 
-	response := &GetNodeConfigResponse{
+	response := &GetNodeDRBDAllocationResponse{
 		Body:         bodyBytes,
 		HTTPResponse: rsp,
 	}
 
 	switch {
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
-		var dest ObjectConfig
+		var dest DRBDAllocation
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
 			return nil, err
 		}
@@ -13595,20 +14805,6 @@ func ParseGetNodeConfigResponse(rsp *http.Response) (*GetNodeConfigResponse, err
 		}
 		response.JSON400 = &dest
 
-	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401:
-		var dest N401
-		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
-			return nil, err
-		}
-		response.JSON401 = &dest
-
-	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 403:
-		var dest N403
-		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
-			return nil, err
-		}
-		response.JSON403 = &dest
-
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 500:
 		var dest N500
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
@@ -13621,22 +14817,22 @@ func ParseGetNodeConfigResponse(rsp *http.Response) (*GetNodeConfigResponse, err
 	return response, nil
 }
 
-// ParseGetNodeConfigGetResponse parses an HTTP response from a GetNodeConfigGetWithResponse call
-func ParseGetNodeConfigGetResponse(rsp *http.Response) (*GetNodeConfigGetResponse, error) {
+// ParseGetNodeDRBDConfigResponse parses an HTTP response from a GetNodeDRBDConfigWithResponse call
+func ParseGetNodeDRBDConfigResponse(rsp *http.Response) (*GetNodeDRBDConfigResponse, error) {
 	bodyBytes, err := io.ReadAll(rsp.Body)
 	defer func() { _ = rsp.Body.Close() }()
 	if err != nil {
 		return nil, err
 	}
 
-	response := &GetNodeConfigGetResponse{
+	response := &GetNodeDRBDConfigResponse{
 		Body:         bodyBytes,
 		HTTPResponse: rsp,
 	}
 
 	switch {
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
-		var dest KeywordList
+		var dest DRBDConfig
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
 			return nil, err
 		}
@@ -13675,27 +14871,20 @@ func ParseGetNodeConfigGetResponse(rsp *http.Response) (*GetNodeConfigGetRespons
 	return response, nil
 }
 
-// ParsePostNodeConfigUpdateResponse parses an HTTP response from a PostNodeConfigUpdateWithResponse call
-func ParsePostNodeConfigUpdateResponse(rsp *http.Response) (*PostNodeConfigUpdateResponse, error) {
+// ParsePostNodeDRBDConfigResponse parses an HTTP response from a PostNodeDRBDConfigWithResponse call
+func ParsePostNodeDRBDConfigResponse(rsp *http.Response) (*PostNodeDRBDConfigResponse, error) {
 	bodyBytes, err := io.ReadAll(rsp.Body)
 	defer func() { _ = rsp.Body.Close() }()
 	if err != nil {
 		return nil, err
 	}
 
-	response := &PostNodeConfigUpdateResponse{
+	response := &PostNodeDRBDConfigResponse{
 		Body:         bodyBytes,
 		HTTPResponse: rsp,
 	}
 
 	switch {
-	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
-		var dest Committed
-		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
-			return nil, err
-		}
-		response.JSON200 = &dest
-
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
 		var dest N400
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
@@ -13729,22 +14918,22 @@ func ParsePostNodeConfigUpdateResponse(rsp *http.Response) (*PostNodeConfigUpdat
 	return response, nil
 }
 
-// ParsePostDaemonRestartResponse parses an HTTP response from a PostDaemonRestartWithResponse call
-func ParsePostDaemonRestartResponse(rsp *http.Response) (*PostDaemonRestartResponse, error) {
+// ParseGetNodeDriverResponse parses an HTTP response from a GetNodeDriverWithResponse call
+func ParseGetNodeDriverResponse(rsp *http.Response) (*GetNodeDriverResponse, error) {
 	bodyBytes, err := io.ReadAll(rsp.Body)
 	defer func() { _ = rsp.Body.Close() }()
 	if err != nil {
 		return nil, err
 	}
 
-	response := &PostDaemonRestartResponse{
+	response := &GetNodeDriverResponse{
 		Body:         bodyBytes,
 		HTTPResponse: rsp,
 	}
 
 	switch {
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
-		var dest N200
+		var dest DriverList
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
 			return nil, err
 		}
@@ -13783,22 +14972,22 @@ func ParsePostDaemonRestartResponse(rsp *http.Response) (*PostDaemonRestartRespo
 	return response, nil
 }
 
-// ParsePostDaemonShutdownResponse parses an HTTP response from a PostDaemonShutdownWithResponse call
-func ParsePostDaemonShutdownResponse(rsp *http.Response) (*PostDaemonShutdownResponse, error) {
+// ParseGetInstanceResponse parses an HTTP response from a GetInstanceWithResponse call
+func ParseGetInstanceResponse(rsp *http.Response) (*GetInstanceResponse, error) {
 	bodyBytes, err := io.ReadAll(rsp.Body)
 	defer func() { _ = rsp.Body.Close() }()
 	if err != nil {
 		return nil, err
 	}
 
-	response := &PostDaemonShutdownResponse{
+	response := &GetInstanceResponse{
 		Body:         bodyBytes,
 		HTTPResponse: rsp,
 	}
 
 	switch {
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
-		var dest DaemonPid
+		var dest InstanceItem
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
 			return nil, err
 		}
@@ -13837,22 +15026,22 @@ func ParsePostDaemonShutdownResponse(rsp *http.Response) (*PostDaemonShutdownRes
 	return response, nil
 }
 
-// ParsePostDaemonStopResponse parses an HTTP response from a PostDaemonStopWithResponse call
-func ParsePostDaemonStopResponse(rsp *http.Response) (*PostDaemonStopResponse, error) {
+// ParsePostInstanceActionBootResponse parses an HTTP response from a PostInstanceActionBootWithResponse call
+func ParsePostInstanceActionBootResponse(rsp *http.Response) (*PostInstanceActionBootResponse, error) {
 	bodyBytes, err := io.ReadAll(rsp.Body)
 	defer func() { _ = rsp.Body.Close() }()
 	if err != nil {
 		return nil, err
 	}
 
-	response := &PostDaemonStopResponse{
+	response := &PostInstanceActionBootResponse{
 		Body:         bodyBytes,
 		HTTPResponse: rsp,
 	}
 
 	switch {
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
-		var dest DaemonPid
+		var dest InstanceActionAccepted
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
 			return nil, err
 		}
@@ -13891,20 +15080,27 @@ func ParsePostDaemonStopResponse(rsp *http.Response) (*PostDaemonStopResponse, e
 	return response, nil
 }
 
-// ParseGetDaemonEventsResponse parses an HTTP response from a GetDaemonEventsWithResponse call
-func ParseGetDaemonEventsResponse(rsp *http.Response) (*GetDaemonEventsResponse, error) {
+// ParsePostInstanceActionDeleteResponse parses an HTTP response from a PostInstanceActionDeleteWithResponse call
+func ParsePostInstanceActionDeleteResponse(rsp *http.Response) (*PostInstanceActionDeleteResponse, error) {
 	bodyBytes, err := io.ReadAll(rsp.Body)
 	defer func() { _ = rsp.Body.Close() }()
 	if err != nil {
 		return nil, err
 	}
 
-	response := &GetDaemonEventsResponse{
+	response := &PostInstanceActionDeleteResponse{
 		Body:         bodyBytes,
 		HTTPResponse: rsp,
 	}
 
 	switch {
+	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
+		var dest InstanceActionAccepted
+		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
+			return nil, err
+		}
+		response.JSON200 = &dest
+
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
 		var dest N400
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
@@ -13938,22 +15134,22 @@ func ParseGetDaemonEventsResponse(rsp *http.Response) (*GetDaemonEventsResponse,
 	return response, nil
 }
 
-// ParseGetNodeDRBDAllocationResponse parses an HTTP response from a GetNodeDRBDAllocationWithResponse call
-func ParseGetNodeDRBDAllocationResponse(rsp *http.Response) (*GetNodeDRBDAllocationResponse, error) {
+// ParsePostInstanceActionFreezeResponse parses an HTTP response from a PostInstanceActionFreezeWithResponse call
+func ParsePostInstanceActionFreezeResponse(rsp *http.Response) (*PostInstanceActionFreezeResponse, error) {
 	bodyBytes, err := io.ReadAll(rsp.Body)
 	defer func() { _ = rsp.Body.Close() }()
 	if err != nil {
 		return nil, err
 	}
 
-	response := &GetNodeDRBDAllocationResponse{
+	response := &PostInstanceActionFreezeResponse{
 		Body:         bodyBytes,
 		HTTPResponse: rsp,
 	}
 
 	switch {
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
-		var dest DRBDAllocation
+		var dest InstanceActionAccepted
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
 			return nil, err
 		}
@@ -13966,6 +15162,20 @@ func ParseGetNodeDRBDAllocationResponse(rsp *http.Response) (*GetNodeDRBDAllocat
 		}
 		response.JSON400 = &dest
 
+	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401:
+		var dest N401
+		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
+			return nil, err
+		}
+		response.JSON401 = &dest
+
+	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 403:
+		var dest N403
+		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
+			return nil, err
+		}
+		response.JSON403 = &dest
+
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 500:
 		var dest N500
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
@@ -13978,22 +15188,22 @@ func ParseGetNodeDRBDAllocationResponse(rsp *http.Response) (*GetNodeDRBDAllocat
 	return response, nil
 }
 
-// ParseGetNodeDRBDConfigResponse parses an HTTP response from a GetNodeDRBDConfigWithResponse call
-func ParseGetNodeDRBDConfigResponse(rsp *http.Response) (*GetNodeDRBDConfigResponse, error) {
+// ParsePostInstanceActionProvisionResponse parses an HTTP response from a PostInstanceActionProvisionWithResponse call
+func ParsePostInstanceActionProvisionResponse(rsp *http.Response) (*PostInstanceActionProvisionResponse, error) {
 	bodyBytes, err := io.ReadAll(rsp.Body)
 	defer func() { _ = rsp.Body.Close() }()
 	if err != nil {
 		return nil, err
 	}
 
-	response := &GetNodeDRBDConfigResponse{
+	response := &PostInstanceActionProvisionResponse{
 		Body:         bodyBytes,
 		HTTPResponse: rsp,
 	}
 
 	switch {
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
-		var dest DRBDConfig
+		var dest InstanceActionAccepted
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
 			return nil, err
 		}
@@ -14032,20 +15242,27 @@ func ParseGetNodeDRBDConfigResponse(rsp *http.Response) (*GetNodeDRBDConfigRespo
 	return response, nil
 }
 
-// ParsePostNodeDRBDConfigResponse parses an HTTP response from a PostNodeDRBDConfigWithResponse call
-func ParsePostNodeDRBDConfigResponse(rsp *http.Response) (*PostNodeDRBDConfigResponse, error) {
+// ParsePostInstanceActionPRStartResponse parses an HTTP response from a PostInstanceActionPRStartWithResponse call
+func ParsePostInstanceActionPRStartResponse(rsp *http.Response) (*PostInstanceActionPRStartResponse, error) {
 	bodyBytes, err := io.ReadAll(rsp.Body)
 	defer func() { _ = rsp.Body.Close() }()
 	if err != nil {
 		return nil, err
 	}
 
-	response := &PostNodeDRBDConfigResponse{
+	response := &PostInstanceActionPRStartResponse{
 		Body:         bodyBytes,
 		HTTPResponse: rsp,
 	}
 
 	switch {
+	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
+		var dest InstanceActionAccepted
+		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
+			return nil, err
+		}
+		response.JSON200 = &dest
+
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
 		var dest N400
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
@@ -14079,22 +15296,22 @@ func ParsePostNodeDRBDConfigResponse(rsp *http.Response) (*PostNodeDRBDConfigRes
 	return response, nil
 }
 
-// ParseGetNodeDriverResponse parses an HTTP response from a GetNodeDriverWithResponse call
-func ParseGetNodeDriverResponse(rsp *http.Response) (*GetNodeDriverResponse, error) {
+// ParsePostInstanceActionPRStopResponse parses an HTTP response from a PostInstanceActionPRStopWithResponse call
+func ParsePostInstanceActionPRStopResponse(rsp *http.Response) (*PostInstanceActionPRStopResponse, error) {
 	bodyBytes, err := io.ReadAll(rsp.Body)
 	defer func() { _ = rsp.Body.Close() }()
 	if err != nil {
 		return nil, err
 	}
 
-	response := &GetNodeDriverResponse{
+	response := &PostInstanceActionPRStopResponse{
 		Body:         bodyBytes,
 		HTTPResponse: rsp,
 	}
 
 	switch {
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
-		var dest DriverList
+		var dest InstanceActionAccepted
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
 			return nil, err
 		}
@@ -14133,22 +15350,22 @@ func ParseGetNodeDriverResponse(rsp *http.Response) (*GetNodeDriverResponse, err
 	return response, nil
 }
 
-// ParseGetInstanceResponse parses an HTTP response from a GetInstanceWithResponse call
-func ParseGetInstanceResponse(rsp *http.Response) (*GetInstanceResponse, error) {
+// ParsePostInstanceActionShutdownResponse parses an HTTP response from a PostInstanceActionShutdownWithResponse call
+func ParsePostInstanceActionShutdownResponse(rsp *http.Response) (*PostInstanceActionShutdownResponse, error) {
 	bodyBytes, err := io.ReadAll(rsp.Body)
 	defer func() { _ = rsp.Body.Close() }()
 	if err != nil {
 		return nil, err
 	}
 
-	response := &GetInstanceResponse{
+	response := &PostInstanceActionShutdownResponse{
 		Body:         bodyBytes,
 		HTTPResponse: rsp,
 	}
 
 	switch {
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
-		var dest InstanceItem
+		var dest InstanceActionAccepted
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
 			return nil, err
 		}
@@ -14187,15 +15404,15 @@ func ParseGetInstanceResponse(rsp *http.Response) (*GetInstanceResponse, error)
 	return response, nil
 }
 
-// ParsePostInstanceActionBootResponse parses an HTTP response from a PostInstanceActionBootWithResponse call
-func ParsePostInstanceActionBootResponse(rsp *http.Response) (*PostInstanceActionBootResponse, error) {
+// ParsePostInstanceActionStartResponse parses an HTTP response from a PostInstanceActionStartWithResponse call
+func ParsePostInstanceActionStartResponse(rsp *http.Response) (*PostInstanceActionStartResponse, error) {
 	bodyBytes, err := io.ReadAll(rsp.Body)
 	defer func() { _ = rsp.Body.Close() }()
 	if err != nil {
 		return nil, err
 	}
 
-	response := &PostInstanceActionBootResponse{
+	response := &PostInstanceActionStartResponse{
 		Body:         bodyBytes,
 		HTTPResponse: rsp,
 	}
@@ -14241,15 +15458,15 @@ func ParsePostInstanceActionBootResponse(rsp *http.Response) (*PostInstanceActio
 	return response, nil
 }
 
-// ParsePostInstanceActionDeleteResponse parses an HTTP response from a PostInstanceActionDeleteWithResponse call
-func ParsePostInstanceActionDeleteResponse(rsp *http.Response) (*PostInstanceActionDeleteResponse, error) {
+// ParsePostInstanceActionStartStandbyResponse parses an HTTP response from a PostInstanceActionStartStandbyWithResponse call
+func ParsePostInstanceActionStartStandbyResponse(rsp *http.Response) (*PostInstanceActionStartStandbyResponse, error) {
 	bodyBytes, err := io.ReadAll(rsp.Body)
 	defer func() { _ = rsp.Body.Close() }()
 	if err != nil {
 		return nil, err
 	}
 
-	response := &PostInstanceActionDeleteResponse{
+	response := &PostInstanceActionStartStandbyResponse{
 		Body:         bodyBytes,
 		HTTPResponse: rsp,
 	}
@@ -14295,15 +15512,15 @@ func ParsePostInstanceActionDeleteResponse(rsp *http.Response) (*PostInstanceAct
 	return response, nil
 }
 
-// ParsePostInstanceActionFreezeResponse parses an HTTP response from a PostInstanceActionFreezeWithResponse call
-func ParsePostInstanceActionFreezeResponse(rsp *http.Response) (*PostInstanceActionFreezeResponse, error) {
+// ParsePostInstanceActionStopResponse parses an HTTP response from a PostInstanceActionStopWithResponse call
+func ParsePostInstanceActionStopResponse(rsp *http.Response) (*PostInstanceActionStopResponse, error) {
 	bodyBytes, err := io.ReadAll(rsp.Body)
 	defer func() { _ = rsp.Body.Close() }()
 	if err != nil {
 		return nil, err
 	}
 
-	response := &PostInstanceActionFreezeResponse{
+	response := &PostInstanceActionStopResponse{
 		Body:         bodyBytes,
 		HTTPResponse: rsp,
 	}
@@ -14349,15 +15566,15 @@ func ParsePostInstanceActionFreezeResponse(rsp *http.Response) (*PostInstanceAct
 	return response, nil
 }
 
-// ParsePostInstanceActionProvisionResponse parses an HTTP response from a PostInstanceActionProvisionWithResponse call
-func ParsePostInstanceActionProvisionResponse(rsp *http.Response) (*PostInstanceActionProvisionResponse, error) {
+// ParsePostInstanceActionUnfreezeResponse parses an HTTP response from a PostInstanceActionUnfreezeWithResponse call
+func ParsePostInstanceActionUnfreezeResponse(rsp *http.Response) (*PostInstanceActionUnfreezeResponse, error) {
 	bodyBytes, err := io.ReadAll(rsp.Body)
 	defer func() { _ = rsp.Body.Close() }()
 	if err != nil {
 		return nil, err
 	}
 
-	response := &PostInstanceActionProvisionResponse{
+	response := &PostInstanceActionUnfreezeResponse{
 		Body:         bodyBytes,
 		HTTPResponse: rsp,
 	}
@@ -14403,15 +15620,15 @@ func ParsePostInstanceActionProvisionResponse(rsp *http.Response) (*PostInstance
 	return response, nil
 }
 
-// ParsePostInstanceActionPRStartResponse parses an HTTP response from a PostInstanceActionPRStartWithResponse call
-func ParsePostInstanceActionPRStartResponse(rsp *http.Response) (*PostInstanceActionPRStartResponse, error) {
+// ParsePostInstanceActionUnprovisionResponse parses an HTTP response from a PostInstanceActionUnprovisionWithResponse call
+func ParsePostInstanceActionUnprovisionResponse(rsp *http.Response) (*PostInstanceActionUnprovisionResponse, error) {
 	bodyBytes, err := io.ReadAll(rsp.Body)
 	defer func() { _ = rsp.Body.Close() }()
 	if err != nil {
 		return nil, err
 	}
 
-	response := &PostInstanceActionPRStartResponse{
+	response := &PostInstanceActionUnprovisionResponse{
 		Body:         bodyBytes,
 		HTTPResponse: rsp,
 	}
@@ -14457,27 +15674,20 @@ func ParsePostInstanceActionPRStartResponse(rsp *http.Response) (*PostInstanceAc
 	return response, nil
 }
 
-// ParsePostInstanceActionPRStopResponse parses an HTTP response from a PostInstanceActionPRStopWithResponse call
-func ParsePostInstanceActionPRStopResponse(rsp *http.Response) (*PostInstanceActionPRStopResponse, error) {
+// ParsePostInstanceClearResponse parses an HTTP response from a PostInstanceClearWithResponse call
+func ParsePostInstanceClearResponse(rsp *http.Response) (*PostInstanceClearResponse, error) {
 	bodyBytes, err := io.ReadAll(rsp.Body)
 	defer func() { _ = rsp.Body.Close() }()
 	if err != nil {
 		return nil, err
 	}
 
-	response := &PostInstanceActionPRStopResponse{
+	response := &PostInstanceClearResponse{
 		Body:         bodyBytes,
 		HTTPResponse: rsp,
 	}
 
 	switch {
-	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
-		var dest InstanceActionAccepted
-		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
-			return nil, err
-		}
-		response.JSON200 = &dest
-
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
 		var dest N400
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
@@ -14511,27 +15721,20 @@ func ParsePostInstanceActionPRStopResponse(rsp *http.Response) (*PostInstanceAct
 	return response, nil
 }
 
-// ParsePostInstanceActionShutdownResponse parses an HTTP response from a PostInstanceActionShutdownWithResponse call
-func ParsePostInstanceActionShutdownResponse(rsp *http.Response) (*PostInstanceActionShutdownResponse, error) {
+// ParsePostInstanceStateFileResponse parses an HTTP response from a PostInstanceStateFileWithResponse call
+func ParsePostInstanceStateFileResponse(rsp *http.Response) (*PostInstanceStateFileResponse, error) {
 	bodyBytes, err := io.ReadAll(rsp.Body)
 	defer func() { _ = rsp.Body.Close() }()
 	if err != nil {
 		return nil, err
 	}
 
-	response := &PostInstanceActionShutdownResponse{
+	response := &PostInstanceStateFileResponse{
 		Body:         bodyBytes,
 		HTTPResponse: rsp,
 	}
 
 	switch {
-	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
-		var dest InstanceActionAccepted
-		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
-			return nil, err
-		}
-		response.JSON200 = &dest
-
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
 		var dest N400
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
@@ -14553,6 +15756,20 @@ func ParsePostInstanceActionShutdownResponse(rsp *http.Response) (*PostInstanceA
 		}
 		response.JSON403 = &dest
 
+	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
+		var dest N404
+		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
+			return nil, err
+		}
+		response.JSON404 = &dest
+
+	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 409:
+		var dest N409
+		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
+			return nil, err
+		}
+		response.JSON409 = &dest
+
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 500:
 		var dest N500
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
@@ -14565,34 +15782,20 @@ func ParsePostInstanceActionShutdownResponse(rsp *http.Response) (*PostInstanceA
 	return response, nil
 }
 
-// ParsePostInstanceActionStartResponse parses an HTTP response from a PostInstanceActionStartWithResponse call
-func ParsePostInstanceActionStartResponse(rsp *http.Response) (*PostInstanceActionStartResponse, error) {
+// ParseGetNodeLogsResponse parses an HTTP response from a GetNodeLogsWithResponse call
+func ParseGetNodeLogsResponse(rsp *http.Response) (*GetNodeLogsResponse, error) {
 	bodyBytes, err := io.ReadAll(rsp.Body)
 	defer func() { _ = rsp.Body.Close() }()
 	if err != nil {
 		return nil, err
 	}
 
-	response := &PostInstanceActionStartResponse{
+	response := &GetNodeLogsResponse{
 		Body:         bodyBytes,
 		HTTPResponse: rsp,
 	}
 
 	switch {
-	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
-		var dest InstanceActionAccepted
-		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
-			return nil, err
-		}
-		response.JSON200 = &dest
-
-	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
-		var dest N400
-		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
-			return nil, err
-		}
-		response.JSON400 = &dest
-
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401:
 		var dest N401
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
@@ -14619,27 +15822,20 @@ func ParsePostInstanceActionStartResponse(rsp *http.Response) (*PostInstanceActi
 	return response, nil
 }
 
-// ParsePostInstanceActionStartStandbyResponse parses an HTTP response from a PostInstanceActionStartStandbyWithResponse call
-func ParsePostInstanceActionStartStandbyResponse(rsp *http.Response) (*PostInstanceActionStartStandbyResponse, error) {
+// ParseGetInstanceLogsResponse parses an HTTP response from a GetInstanceLogsWithResponse call
+func ParseGetInstanceLogsResponse(rsp *http.Response) (*GetInstanceLogsResponse, error) {
 	bodyBytes, err := io.ReadAll(rsp.Body)
 	defer func() { _ = rsp.Body.Close() }()
 	if err != nil {
 		return nil, err
 	}
 
-	response := &PostInstanceActionStartStandbyResponse{
+	response := &GetInstanceLogsResponse{
 		Body:         bodyBytes,
 		HTTPResponse: rsp,
 	}
 
 	switch {
-	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
-		var dest InstanceActionAccepted
-		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
-			return nil, err
-		}
-		response.JSON200 = &dest
-
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
 		var dest N400
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
@@ -14673,22 +15869,22 @@ func ParsePostInstanceActionStartStandbyResponse(rsp *http.Response) (*PostInsta
 	return response, nil
 }
 
-// ParsePostInstanceActionStopResponse parses an HTTP response from a PostInstanceActionStopWithResponse call
-func ParsePostInstanceActionStopResponse(rsp *http.Response) (*PostInstanceActionStopResponse, error) {
+// ParseGetObjectScheduleResponse parses an HTTP response from a GetObjectScheduleWithResponse call
+func ParseGetObjectScheduleResponse(rsp *http.Response) (*GetObjectScheduleResponse, error) {
 	bodyBytes, err := io.ReadAll(rsp.Body)
 	defer func() { _ = rsp.Body.Close() }()
 	if err != nil {
 		return nil, err
 	}
 
-	response := &PostInstanceActionStopResponse{
+	response := &GetObjectScheduleResponse{
 		Body:         bodyBytes,
 		HTTPResponse: rsp,
 	}
 
 	switch {
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
-		var dest InstanceActionAccepted
+		var dest ScheduleList
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
 			return nil, err
 		}
@@ -14727,27 +15923,20 @@ func ParsePostInstanceActionStopResponse(rsp *http.Response) (*PostInstanceActio
 	return response, nil
 }
 
-// ParsePostInstanceActionUnfreezeResponse parses an HTTP response from a PostInstanceActionUnfreezeWithResponse call
-func ParsePostInstanceActionUnfreezeResponse(rsp *http.Response) (*PostInstanceActionUnfreezeResponse, error) {
+// ParseGetNodePingResponse parses an HTTP response from a GetNodePingWithResponse call
+func ParseGetNodePingResponse(rsp *http.Response) (*GetNodePingResponse, error) {
 	bodyBytes, err := io.ReadAll(rsp.Body)
 	defer func() { _ = rsp.Body.Close() }()
 	if err != nil {
 		return nil, err
 	}
 
-	response := &PostInstanceActionUnfreezeResponse{
+	response := &GetNodePingResponse{
 		Body:         bodyBytes,
 		HTTPResponse: rsp,
 	}
 
 	switch {
-	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
-		var dest InstanceActionAccepted
-		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
-			return nil, err
-		}
-		response.JSON200 = &dest
-
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
 		var dest N400
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
@@ -14781,22 +15970,22 @@ func ParsePostInstanceActionUnfreezeResponse(rsp *http.Response) (*PostInstanceA
 	return response, nil
 }
 
-// ParsePostInstanceActionUnprovisionResponse parses an HTTP response from a PostInstanceActionUnprovisionWithResponse call
-func ParsePostInstanceActionUnprovisionResponse(rsp *http.Response) (*PostInstanceActionUnprovisionResponse, error) {
+// ParseGetNodeScheduleResponse parses an HTTP response from a GetNodeScheduleWithResponse call
+func ParseGetNodeScheduleResponse(rsp *http.Response) (*GetNodeScheduleResponse, error) {
 	bodyBytes, err := io.ReadAll(rsp.Body)
 	defer func() { _ = rsp.Body.Close() }()
 	if err != nil {
 		return nil, err
 	}
 
-	response := &PostInstanceActionUnprovisionResponse{
+	response := &GetNodeScheduleResponse{
 		Body:         bodyBytes,
 		HTTPResponse: rsp,
 	}
 
 	switch {
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
-		var dest InstanceActionAccepted
+		var dest ScheduleList
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
 			return nil, err
 		}
@@ -14835,20 +16024,27 @@ func ParsePostInstanceActionUnprovisionResponse(rsp *http.Response) (*PostInstan
 	return response, nil
 }
 
-// ParsePostInstanceClearResponse parses an HTTP response from a PostInstanceClearWithResponse call
-func ParsePostInstanceClearResponse(rsp *http.Response) (*PostInstanceClearResponse, error) {
+// ParseGetNodeSystemDiskResponse parses an HTTP response from a GetNodeSystemDiskWithResponse call
+func ParseGetNodeSystemDiskResponse(rsp *http.Response) (*GetNodeSystemDiskResponse, error) {
 	bodyBytes, err := io.ReadAll(rsp.Body)
 	defer func() { _ = rsp.Body.Close() }()
 	if err != nil {
 		return nil, err
 	}
 
-	response := &PostInstanceClearResponse{
+	response := &GetNodeSystemDiskResponse{
 		Body:         bodyBytes,
 		HTTPResponse: rsp,
 	}
 
 	switch {
+	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
+		var dest DiskList
+		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
+			return nil, err
+		}
+		response.JSON200 = &dest
+
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
 		var dest N400
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
@@ -14882,20 +16078,27 @@ func ParsePostInstanceClearResponse(rsp *http.Response) (*PostInstanceClearRespo
 	return response, nil
 }
 
-// ParsePostInstanceStateFileResponse parses an HTTP response from a PostInstanceStateFileWithResponse call
-func ParsePostInstanceStateFileResponse(rsp *http.Response) (*PostInstanceStateFileResponse, error) {
+// ParseGetNodeSystemGroupResponse parses an HTTP response from a GetNodeSystemGroupWithResponse call
+func ParseGetNodeSystemGroupResponse(rsp *http.Response) (*GetNodeSystemGroupResponse, error) {
 	bodyBytes, err := io.ReadAll(rsp.Body)
 	defer func() { _ = rsp.Body.Close() }()
 	if err != nil {
 		return nil, err
 	}
 
-	response := &PostInstanceStateFileResponse{
+	response := &GetNodeSystemGroupResponse{
 		Body:         bodyBytes,
 		HTTPResponse: rsp,
 	}
 
 	switch {
+	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
+		var dest GroupList
+		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
+			return nil, err
+		}
+		response.JSON200 = &dest
+
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
 		var dest N400
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
@@ -14917,20 +16120,6 @@ func ParsePostInstanceStateFileResponse(rsp *http.Response) (*PostInstanceStateF
 		}
 		response.JSON403 = &dest
 
-	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
-		var dest N404
-		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
-			return nil, err
-		}
-		response.JSON404 = &dest
-
-	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 409:
-		var dest N409
-		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
-			return nil, err
-		}
-		response.JSON409 = &dest
-
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 500:
 		var dest N500
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
@@ -14943,20 +16132,34 @@ func ParsePostInstanceStateFileResponse(rsp *http.Response) (*PostInstanceStateF
 	return response, nil
 }
 
-// ParseGetNodeLogsResponse parses an HTTP response from a GetNodeLogsWithResponse call
-func ParseGetNodeLogsResponse(rsp *http.Response) (*GetNodeLogsResponse, error) {
+// ParseGetNodeSystemHardwareResponse parses an HTTP response from a GetNodeSystemHardwareWithResponse call
+func ParseGetNodeSystemHardwareResponse(rsp *http.Response) (*GetNodeSystemHardwareResponse, error) {
 	bodyBytes, err := io.ReadAll(rsp.Body)
 	defer func() { _ = rsp.Body.Close() }()
 	if err != nil {
 		return nil, err
 	}
 
-	response := &GetNodeLogsResponse{
+	response := &GetNodeSystemHardwareResponse{
 		Body:         bodyBytes,
 		HTTPResponse: rsp,
 	}
 
 	switch {
+	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
+		var dest HardwareList
+		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
+			return nil, err
+		}
+		response.JSON200 = &dest
+
+	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
+		var dest N400
+		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
+			return nil, err
+		}
+		response.JSON400 = &dest
+
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401:
 		var dest N401
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
@@ -14983,20 +16186,27 @@ func ParseGetNodeLogsResponse(rsp *http.Response) (*GetNodeLogsResponse, error)
 	return response, nil
 }
 
-// ParseGetInstanceLogsResponse parses an HTTP response from a GetInstanceLogsWithResponse call
-func ParseGetInstanceLogsResponse(rsp *http.Response) (*GetInstanceLogsResponse, error) {
+// ParseGetNodeSystemIPAddressResponse parses an HTTP response from a GetNodeSystemIPAddressWithResponse call
+func ParseGetNodeSystemIPAddressResponse(rsp *http.Response) (*GetNodeSystemIPAddressResponse, error) {
 	bodyBytes, err := io.ReadAll(rsp.Body)
 	defer func() { _ = rsp.Body.Close() }()
 	if err != nil {
 		return nil, err
 	}
 
-	response := &GetInstanceLogsResponse{
+	response := &GetNodeSystemIPAddressResponse{
 		Body:         bodyBytes,
 		HTTPResponse: rsp,
 	}
 
 	switch {
+	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
+		var dest IPAddressList
+		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
+			return nil, err
+		}
+		response.JSON200 = &dest
+
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
 		var dest N400
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
@@ -15030,22 +16240,22 @@ func ParseGetInstanceLogsResponse(rsp *http.Response) (*GetInstanceLogsResponse,
 	return response, nil
 }
 
-// ParseGetObjectScheduleResponse parses an HTTP response from a GetObjectScheduleWithResponse call
-func ParseGetObjectScheduleResponse(rsp *http.Response) (*GetObjectScheduleResponse, error) {
+// ParseGetNodeSystemPackageResponse parses an HTTP response from a GetNodeSystemPackageWithResponse call
+func ParseGetNodeSystemPackageResponse(rsp *http.Response) (*GetNodeSystemPackageResponse, error) {
 	bodyBytes, err := io.ReadAll(rsp.Body)
 	defer func() { _ = rsp.Body.Close() }()
 	if err != nil {
 		return nil, err
 	}
 
-	response := &GetObjectScheduleResponse{
+	response := &GetNodeSystemPackageResponse{
 		Body:         bodyBytes,
 		HTTPResponse: rsp,
 	}
 
 	switch {
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
-		var dest ScheduleList
+		var dest PackageList
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
 			return nil, err
 		}
@@ -15084,20 +16294,27 @@ func ParseGetObjectScheduleResponse(rsp *http.Response) (*GetObjectScheduleRespo
 	return response, nil
 }
 
-// ParseGetNodePingResponse parses an HTTP response from a GetNodePingWithResponse call
-func ParseGetNodePingResponse(rsp *http.Response) (*GetNodePingResponse, error) {
+// ParseGetNodeSystemPatchResponse parses an HTTP response from a GetNodeSystemPatchWithResponse call
+func ParseGetNodeSystemPatchResponse(rsp *http.Response) (*GetNodeSystemPatchResponse, error) {
 	bodyBytes, err := io.ReadAll(rsp.Body)
 	defer func() { _ = rsp.Body.Close() }()
 	if err != nil {
 		return nil, err
 	}
 
-	response := &GetNodePingResponse{
+	response := &GetNodeSystemPatchResponse{
 		Body:         bodyBytes,
 		HTTPResponse: rsp,
 	}
 
 	switch {
+	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
+		var dest PatchList
+		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
+			return nil, err
+		}
+		response.JSON200 = &dest
+
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
 		var dest N400
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
@@ -15131,22 +16348,22 @@ func ParseGetNodePingResponse(rsp *http.Response) (*GetNodePingResponse, error)
 	return response, nil
 }
 
-// ParseGetNodeScheduleResponse parses an HTTP response from a GetNodeScheduleWithResponse call
-func ParseGetNodeScheduleResponse(rsp *http.Response) (*GetNodeScheduleResponse, error) {
+// ParseGetNodeSystemPropertyResponse parses an HTTP response from a GetNodeSystemPropertyWithResponse call
+func ParseGetNodeSystemPropertyResponse(rsp *http.Response) (*GetNodeSystemPropertyResponse, error) {
 	bodyBytes, err := io.ReadAll(rsp.Body)
 	defer func() { _ = rsp.Body.Close() }()
 	if err != nil {
 		return nil, err
 	}
 
-	response := &GetNodeScheduleResponse{
+	response := &GetNodeSystemPropertyResponse{
 		Body:         bodyBytes,
 		HTTPResponse: rsp,
 	}
 
 	switch {
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
-		var dest ScheduleList
+		var dest PropertyList
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
 			return nil, err
 		}
@@ -15185,22 +16402,22 @@ func ParseGetNodeScheduleResponse(rsp *http.Response) (*GetNodeScheduleResponse,
 	return response, nil
 }
 
-// ParseGetNodeSystemDiskResponse parses an HTTP response from a GetNodeSystemDiskWithResponse call
-func ParseGetNodeSystemDiskResponse(rsp *http.Response) (*GetNodeSystemDiskResponse, error) {
+// ParseGetNodeSystemSANInitiatorResponse parses an HTTP response from a GetNodeSystemSANInitiatorWithResponse call
+func ParseGetNodeSystemSANInitiatorResponse(rsp *http.Response) (*GetNodeSystemSANInitiatorResponse, error) {
 	bodyBytes, err := io.ReadAll(rsp.Body)
 	defer func() { _ = rsp.Body.Close() }()
 	if err != nil {
 		return nil, err
 	}
 
-	response := &GetNodeSystemDiskResponse{
+	response := &GetNodeSystemSANInitiatorResponse{
 		Body:         bodyBytes,
 		HTTPResponse: rsp,
 	}
 
 	switch {
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
-		var dest DiskList
+		var dest SANPathInitiatorList
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
 			return nil, err
 		}
@@ -15239,22 +16456,22 @@ func ParseGetNodeSystemDiskResponse(rsp *http.Response) (*GetNodeSystemDiskRespo
 	return response, nil
 }
 
-// ParseGetNodeSystemGroupResponse parses an HTTP response from a GetNodeSystemGroupWithResponse call
-func ParseGetNodeSystemGroupResponse(rsp *http.Response) (*GetNodeSystemGroupResponse, error) {
+// ParseGetNodeSystemSANPathResponse parses an HTTP response from a GetNodeSystemSANPathWithResponse call
+func ParseGetNodeSystemSANPathResponse(rsp *http.Response) (*GetNodeSystemSANPathResponse, error) {
 	bodyBytes, err := io.ReadAll(rsp.Body)
 	defer func() { _ = rsp.Body.Close() }()
 	if err != nil {
 		return nil, err
 	}
 
-	response := &GetNodeSystemGroupResponse{
+	response := &GetNodeSystemSANPathResponse{
 		Body:         bodyBytes,
 		HTTPResponse: rsp,
 	}
 
 	switch {
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
-		var dest GroupList
+		var dest SANPathList
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
 			return nil, err
 		}
@@ -15293,22 +16510,22 @@ func ParseGetNodeSystemGroupResponse(rsp *http.Response) (*GetNodeSystemGroupRes
 	return response, nil
 }
 
-// ParseGetNodeSystemHardwareResponse parses an HTTP response from a GetNodeSystemHardwareWithResponse call
-func ParseGetNodeSystemHardwareResponse(rsp *http.Response) (*GetNodeSystemHardwareResponse, error) {
+// ParseGetNodeSystemUserResponse parses an HTTP response from a GetNodeSystemUserWithResponse call
+func ParseGetNodeSystemUserResponse(rsp *http.Response) (*GetNodeSystemUserResponse, error) {
 	bodyBytes, err := io.ReadAll(rsp.Body)
 	defer func() { _ = rsp.Body.Close() }()
 	if err != nil {
 		return nil, err
 	}
 
-	response := &GetNodeSystemHardwareResponse{
+	response := &GetNodeSystemUserResponse{
 		Body:         bodyBytes,
 		HTTPResponse: rsp,
 	}
 
 	switch {
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
-		var dest HardwareList
+		var dest UserList
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
 			return nil, err
 		}
@@ -15347,22 +16564,22 @@ func ParseGetNodeSystemHardwareResponse(rsp *http.Response) (*GetNodeSystemHardw
 	return response, nil
 }
 
-// ParseGetNodeSystemIPAddressResponse parses an HTTP response from a GetNodeSystemIPAddressWithResponse call
-func ParseGetNodeSystemIPAddressResponse(rsp *http.Response) (*GetNodeSystemIPAddressResponse, error) {
+// ParseGetObjectsResponse parses an HTTP response from a GetObjectsWithResponse call
+func ParseGetObjectsResponse(rsp *http.Response) (*GetObjectsResponse, error) {
 	bodyBytes, err := io.ReadAll(rsp.Body)
 	defer func() { _ = rsp.Body.Close() }()
 	if err != nil {
 		return nil, err
 	}
 
-	response := &GetNodeSystemIPAddressResponse{
+	response := &GetObjectsResponse{
 		Body:         bodyBytes,
 		HTTPResponse: rsp,
 	}
 
 	switch {
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
-		var dest IPAddressList
+		var dest ObjectList
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
 			return nil, err
 		}
@@ -15401,34 +16618,27 @@ func ParseGetNodeSystemIPAddressResponse(rsp *http.Response) (*GetNodeSystemIPAd
 	return response, nil
 }
 
-// ParseGetNodeSystemPackageResponse parses an HTTP response from a GetNodeSystemPackageWithResponse call
-func ParseGetNodeSystemPackageResponse(rsp *http.Response) (*GetNodeSystemPackageResponse, error) {
+// ParseGetObjectPathsResponse parses an HTTP response from a GetObjectPathsWithResponse call
+func ParseGetObjectPathsResponse(rsp *http.Response) (*GetObjectPathsResponse, error) {
 	bodyBytes, err := io.ReadAll(rsp.Body)
 	defer func() { _ = rsp.Body.Close() }()
 	if err != nil {
 		return nil, err
 	}
 
-	response := &GetNodeSystemPackageResponse{
+	response := &GetObjectPathsResponse{
 		Body:         bodyBytes,
 		HTTPResponse: rsp,
 	}
 
 	switch {
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
-		var dest PackageList
+		var dest ObjectPaths
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
 			return nil, err
 		}
 		response.JSON200 = &dest
 
-	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
-		var dest N400
-		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
-			return nil, err
-		}
-		response.JSON400 = &dest
-
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401:
 		var dest N401
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
@@ -15455,27 +16665,20 @@ func ParseGetNodeSystemPackageResponse(rsp *http.Response) (*GetNodeSystemPackag
 	return response, nil
 }
 
-// ParseGetNodeSystemPatchResponse parses an HTTP response from a GetNodeSystemPatchWithResponse call
-func ParseGetNodeSystemPatchResponse(rsp *http.Response) (*GetNodeSystemPatchResponse, error) {
+// ParsePostSvcDisableResponse parses an HTTP response from a PostSvcDisableWithResponse call
+func ParsePostSvcDisableResponse(rsp *http.Response) (*PostSvcDisableResponse, error) {
 	bodyBytes, err := io.ReadAll(rsp.Body)
 	defer func() { _ = rsp.Body.Close() }()
 	if err != nil {
 		return nil, err
 	}
 
-	response := &GetNodeSystemPatchResponse{
+	response := &PostSvcDisableResponse{
 		Body:         bodyBytes,
 		HTTPResponse: rsp,
 	}
 
 	switch {
-	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
-		var dest PatchList
-		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
-			return nil, err
-		}
-		response.JSON200 = &dest
-
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
 		var dest N400
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
@@ -15509,27 +16712,20 @@ func ParseGetNodeSystemPatchResponse(rsp *http.Response) (*GetNodeSystemPatchRes
 	return response, nil
 }
 
-// ParseGetNodeSystemPropertyResponse parses an HTTP response from a GetNodeSystemPropertyWithResponse call
-func ParseGetNodeSystemPropertyResponse(rsp *http.Response) (*GetNodeSystemPropertyResponse, error) {
+// ParsePostSvcEnableResponse parses an HTTP response from a PostSvcEnableWithResponse call
+func ParsePostSvcEnableResponse(rsp *http.Response) (*PostSvcEnableResponse, error) {
 	bodyBytes, err := io.ReadAll(rsp.Body)
 	defer func() { _ = rsp.Body.Close() }()
 	if err != nil {
 		return nil, err
 	}
 
-	response := &GetNodeSystemPropertyResponse{
+	response := &PostSvcEnableResponse{
 		Body:         bodyBytes,
 		HTTPResponse: rsp,
 	}
 
 	switch {
-	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
-		var dest PropertyList
-		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
-			return nil, err
-		}
-		response.JSON200 = &dest
-
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
 		var dest N400
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
@@ -15563,34 +16759,27 @@ func ParseGetNodeSystemPropertyResponse(rsp *http.Response) (*GetNodeSystemPrope
 	return response, nil
 }
 
-// ParseGetNodeSystemSANInitiatorResponse parses an HTTP response from a GetNodeSystemSANInitiatorWithResponse call
-func ParseGetNodeSystemSANInitiatorResponse(rsp *http.Response) (*GetNodeSystemSANInitiatorResponse, error) {
+// ParseGetObjectResponse parses an HTTP response from a GetObjectWithResponse call
+func ParseGetObjectResponse(rsp *http.Response) (*GetObjectResponse, error) {
 	bodyBytes, err := io.ReadAll(rsp.Body)
 	defer func() { _ = rsp.Body.Close() }()
 	if err != nil {
 		return nil, err
 	}
 
-	response := &GetNodeSystemSANInitiatorResponse{
+	response := &GetObjectResponse{
 		Body:         bodyBytes,
 		HTTPResponse: rsp,
 	}
 
 	switch {
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
-		var dest SANPathInitiatorList
+		var dest ObjectItem
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
 			return nil, err
 		}
 		response.JSON200 = &dest
 
-	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
-		var dest N400
-		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
-			return nil, err
-		}
-		response.JSON400 = &dest
-
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401:
 		var dest N401
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
@@ -15617,22 +16806,22 @@ func ParseGetNodeSystemSANInitiatorResponse(rsp *http.Response) (*GetNodeSystemS
 	return response, nil
 }
 
-// ParseGetNodeSystemSANPathResponse parses an HTTP response from a GetNodeSystemSANPathWithResponse call
-func ParseGetNodeSystemSANPathResponse(rsp *http.Response) (*GetNodeSystemSANPathResponse, error) {
+// ParsePostObjectActionAbortResponse parses an HTTP response from a PostObjectActionAbortWithResponse call
+func ParsePostObjectActionAbortResponse(rsp *http.Response) (*PostObjectActionAbortResponse, error) {
 	bodyBytes, err := io.ReadAll(rsp.Body)
 	defer func() { _ = rsp.Body.Close() }()
 	if err != nil {
 		return nil, err
 	}
 
-	response := &GetNodeSystemSANPathResponse{
+	response := &PostObjectActionAbortResponse{
 		Body:         bodyBytes,
 		HTTPResponse: rsp,
 	}
 
 	switch {
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
-		var dest SANPathList
+		var dest OrchestrationQueued
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
 			return nil, err
 		}
@@ -15659,6 +16848,20 @@ func ParseGetNodeSystemSANPathResponse(rsp *http.Response) (*GetNodeSystemSANPat
 		}
 		response.JSON403 = &dest
 
+	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 408:
+		var dest N408
+		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
+			return nil, err
+		}
+		response.JSON408 = &dest
+
+	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 409:
+		var dest N409
+		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
+			return nil, err
+		}
+		response.JSON409 = &dest
+
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 500:
 		var dest N500
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
@@ -15671,22 +16874,22 @@ func ParseGetNodeSystemSANPathResponse(rsp *http.Response) (*GetNodeSystemSANPat
 	return response, nil
 }
 
-// ParseGetNodeSystemUserResponse parses an HTTP response from a GetNodeSystemUserWithResponse call
-func ParseGetNodeSystemUserResponse(rsp *http.Response) (*GetNodeSystemUserResponse, error) {
+// ParsePostObjectActionDeleteResponse parses an HTTP response from a PostObjectActionDeleteWithResponse call
+func ParsePostObjectActionDeleteResponse(rsp *http.Response) (*PostObjectActionDeleteResponse, error) {
 	bodyBytes, err := io.ReadAll(rsp.Body)
 	defer func() { _ = rsp.Body.Close() }()
 	if err != nil {
 		return nil, err
 	}
 
-	response := &GetNodeSystemUserResponse{
+	response := &PostObjectActionDeleteResponse{
 		Body:         bodyBytes,
 		HTTPResponse: rsp,
 	}
 
 	switch {
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
-		var dest UserList
+		var dest OrchestrationQueued
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
 			return nil, err
 		}
@@ -15713,6 +16916,20 @@ func ParseGetNodeSystemUserResponse(rsp *http.Response) (*GetNodeSystemUserRespo
 		}
 		response.JSON403 = &dest
 
+	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 408:
+		var dest N408
+		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
+			return nil, err
+		}
+		response.JSON408 = &dest
+
+	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 409:
+		var dest N409
+		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
+			return nil, err
+		}
+		response.JSON409 = &dest
+
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 500:
 		var dest N500
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
@@ -15725,22 +16942,22 @@ func ParseGetNodeSystemUserResponse(rsp *http.Response) (*GetNodeSystemUserRespo
 	return response, nil
 }
 
-// ParseGetObjectsResponse parses an HTTP response from a GetObjectsWithResponse call
-func ParseGetObjectsResponse(rsp *http.Response) (*GetObjectsResponse, error) {
+// ParsePostObjectActionFreezeResponse parses an HTTP response from a PostObjectActionFreezeWithResponse call
+func ParsePostObjectActionFreezeResponse(rsp *http.Response) (*PostObjectActionFreezeResponse, error) {
 	bodyBytes, err := io.ReadAll(rsp.Body)
 	defer func() { _ = rsp.Body.Close() }()
 	if err != nil {
 		return nil, err
 	}
 
-	response := &GetObjectsResponse{
+	response := &PostObjectActionFreezeResponse{
 		Body:         bodyBytes,
 		HTTPResponse: rsp,
 	}
 
 	switch {
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
-		var dest ObjectList
+		var dest OrchestrationQueued
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
 			return nil, err
 		}
@@ -15767,6 +16984,20 @@ func ParseGetObjectsResponse(rsp *http.Response) (*GetObjectsResponse, error) {
 		}
 		response.JSON403 = &dest
 
+	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 408:
+		var dest N408
+		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
+			return nil, err
+		}
+		response.JSON408 = &dest
+
+	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 409:
+		var dest N409
+		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
+			return nil, err
+		}
+		response.JSON409 = &dest
+
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 500:
 		var dest N500
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
@@ -15779,27 +17010,34 @@ func ParseGetObjectsResponse(rsp *http.Response) (*GetObjectsResponse, error) {
 	return response, nil
 }
 
-// ParseGetObjectPathsResponse parses an HTTP response from a GetObjectPathsWithResponse call
-func ParseGetObjectPathsResponse(rsp *http.Response) (*GetObjectPathsResponse, error) {
+// ParsePostObjectActionGivebackResponse parses an HTTP response from a PostObjectActionGivebackWithResponse call
+func ParsePostObjectActionGivebackResponse(rsp *http.Response) (*PostObjectActionGivebackResponse, error) {
 	bodyBytes, err := io.ReadAll(rsp.Body)
 	defer func() { _ = rsp.Body.Close() }()
 	if err != nil {
 		return nil, err
 	}
 
-	response := &GetObjectPathsResponse{
+	response := &PostObjectActionGivebackResponse{
 		Body:         bodyBytes,
 		HTTPResponse: rsp,
 	}
 
 	switch {
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
-		var dest ObjectPaths
+		var dest OrchestrationQueued
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
 			return nil, err
 		}
 		response.JSON200 = &dest
 
+	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
+		var dest N400
+		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
+			return nil, err
+		}
+		response.JSON400 = &dest
+
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401:
 		var dest N401
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
@@ -15814,6 +17052,20 @@ func ParseGetObjectPathsResponse(rsp *http.Response) (*GetObjectPathsResponse, e
 		}
 		response.JSON403 = &dest
 
+	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 408:
+		var dest N408
+		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
+			return nil, err
+		}
+		response.JSON408 = &dest
+
+	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 409:
+		var dest N409
+		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
+			return nil, err
+		}
+		response.JSON409 = &dest
+
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 500:
 		var dest N500
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
@@ -15826,20 +17078,27 @@ func ParseGetObjectPathsResponse(rsp *http.Response) (*GetObjectPathsResponse, e
 	return response, nil
 }
 
-// ParsePostSvcDisableResponse parses an HTTP response from a PostSvcDisableWithResponse call
-func ParsePostSvcDisableResponse(rsp *http.Response) (*PostSvcDisableResponse, error) {
+// ParsePostObjectActionProvisionResponse parses an HTTP response from a PostObjectActionProvisionWithResponse call
+func ParsePostObjectActionProvisionResponse(rsp *http.Response) (*PostObjectActionProvisionResponse, error) {
 	bodyBytes, err := io.ReadAll(rsp.Body)
 	defer func() { _ = rsp.Body.Close() }()
 	if err != nil {
 		return nil, err
 	}
 
-	response := &PostSvcDisableResponse{
+	response := &PostObjectActionProvisionResponse{
 		Body:         bodyBytes,
 		HTTPResponse: rsp,
 	}
 
 	switch {
+	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
+		var dest OrchestrationQueued
+		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
+			return nil, err
+		}
+		response.JSON200 = &dest
+
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
 		var dest N400
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
@@ -15861,6 +17120,20 @@ func ParsePostSvcDisableResponse(rsp *http.Response) (*PostSvcDisableResponse, e
 		}
 		response.JSON403 = &dest
 
+	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 408:
+		var dest N408
+		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
+			return nil, err
+		}
+		response.JSON408 = &dest
+
+	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 409:
+		var dest N409
+		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
+			return nil, err
+		}
+		response.JSON409 = &dest
+
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 500:
 		var dest N500
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
@@ -15873,20 +17146,27 @@ func ParsePostSvcDisableResponse(rsp *http.Response) (*PostSvcDisableResponse, e
 	return response, nil
 }
 
-// ParsePostSvcEnableResponse parses an HTTP response from a PostSvcEnableWithResponse call
-func ParsePostSvcEnableResponse(rsp *http.Response) (*PostSvcEnableResponse, error) {
+// ParsePostObjectActionPurgeResponse parses an HTTP response from a PostObjectActionPurgeWithResponse call
+func ParsePostObjectActionPurgeResponse(rsp *http.Response) (*PostObjectActionPurgeResponse, error) {
 	bodyBytes, err := io.ReadAll(rsp.Body)
 	defer func() { _ = rsp.Body.Close() }()
 	if err != nil {
 		return nil, err
 	}
 
-	response := &PostSvcEnableResponse{
+	response := &PostObjectActionPurgeResponse{
 		Body:         bodyBytes,
 		HTTPResponse: rsp,
 	}
 
 	switch {
+	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
+		var dest OrchestrationQueued
+		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
+			return nil, err
+		}
+		response.JSON200 = &dest
+
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
 		var dest N400
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
@@ -15908,6 +17188,20 @@ func ParsePostSvcEnableResponse(rsp *http.Response) (*PostSvcEnableResponse, err
 		}
 		response.JSON403 = &dest
 
+	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 408:
+		var dest N408
+		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
+			return nil, err
+		}
+		response.JSON408 = &dest
+
+	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 409:
+		var dest N409
+		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
+			return nil, err
+		}
+		response.JSON409 = &dest
+
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 500:
 		var dest N500
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
@@ -15920,27 +17214,34 @@ func ParsePostSvcEnableResponse(rsp *http.Response) (*PostSvcEnableResponse, err
 	return response, nil
 }
 
-// ParseGetObjectResponse parses an HTTP response from a GetObjectWithResponse call
-func ParseGetObjectResponse(rsp *http.Response) (*GetObjectResponse, error) {
+// ParsePostObjectActionRestartResponse parses an HTTP response from a PostObjectActionRestartWithResponse call
+func ParsePostObjectActionRestartResponse(rsp *http.Response) (*PostObjectActionRestartResponse, error) {
 	bodyBytes, err := io.ReadAll(rsp.Body)
 	defer func() { _ = rsp.Body.Close() }()
 	if err != nil {
 		return nil, err
 	}
 
-	response := &GetObjectResponse{
+	response := &PostObjectActionRestartResponse{
 		Body:         bodyBytes,
 		HTTPResponse: rsp,
 	}
 
 	switch {
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
-		var dest ObjectItem
+		var dest OrchestrationQueued
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
 			return nil, err
 		}
 		response.JSON200 = &dest
 
+	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
+		var dest N400
+		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
+			return nil, err
+		}
+		response.JSON400 = &dest
+
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401:
 		var dest N401
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
@@ -15955,6 +17256,20 @@ func ParseGetObjectResponse(rsp *http.Response) (*GetObjectResponse, error) {
 		}
 		response.JSON403 = &dest
 
+	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 408:
+		var dest N408
+		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
+			return nil, err
+		}
+		response.JSON408 = &dest
+
+	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 409:
+		var dest N409
+		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
+			return nil, err
+		}
+		response.JSON409 = &dest
+
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 500:
 		var dest N500
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
@@ -15967,15 +17282,15 @@ func ParseGetObjectResponse(rsp *http.Response) (*GetObjectResponse, error) {
 	return response, nil
 }
 
-// ParsePostObjectActionAbortResponse parses an HTTP response from a PostObjectActionAbortWithResponse call
-func ParsePostObjectActionAbortResponse(rsp *http.Response) (*PostObjectActionAbortResponse, error) {
+// ParsePostObjectActionStartResponse parses an HTTP response from a PostObjectActionStartWithResponse call
+func ParsePostObjectActionStartResponse(rsp *http.Response) (*PostObjectActionStartResponse, error) {
 	bodyBytes, err := io.ReadAll(rsp.Body)
 	defer func() { _ = rsp.Body.Close() }()
 	if err != nil {
 		return nil, err
 	}
 
-	response := &PostObjectActionAbortResponse{
+	response := &PostObjectActionStartResponse{
 		Body:         bodyBytes,
 		HTTPResponse: rsp,
 	}
@@ -16035,15 +17350,15 @@ func ParsePostObjectActionAbortResponse(rsp *http.Response) (*PostObjectActionAb
 	return response, nil
 }
 
-// ParsePostObjectActionDeleteResponse parses an HTTP response from a PostObjectActionDeleteWithResponse call
-func ParsePostObjectActionDeleteResponse(rsp *http.Response) (*PostObjectActionDeleteResponse, error) {
+// ParsePostObjectActionStopResponse parses an HTTP response from a PostObjectActionStopWithResponse call
+func ParsePostObjectActionStopResponse(rsp *http.Response) (*PostObjectActionStopResponse, error) {
 	bodyBytes, err := io.ReadAll(rsp.Body)
 	defer func() { _ = rsp.Body.Close() }()
 	if err != nil {
 		return nil, err
 	}
 
-	response := &PostObjectActionDeleteResponse{
+	response := &PostObjectActionStopResponse{
 		Body:         bodyBytes,
 		HTTPResponse: rsp,
 	}
@@ -16103,15 +17418,15 @@ func ParsePostObjectActionDeleteResponse(rsp *http.Response) (*PostObjectActionD
 	return response, nil
 }
 
-// ParsePostObjectActionFreezeResponse parses an HTTP response from a PostObjectActionFreezeWithResponse call
-func ParsePostObjectActionFreezeResponse(rsp *http.Response) (*PostObjectActionFreezeResponse, error) {
+// ParsePostObjectActionSwitchResponse parses an HTTP response from a PostObjectActionSwitchWithResponse call
+func ParsePostObjectActionSwitchResponse(rsp *http.Response) (*PostObjectActionSwitchResponse, error) {
 	bodyBytes, err := io.ReadAll(rsp.Body)
 	defer func() { _ = rsp.Body.Close() }()
 	if err != nil {
 		return nil, err
 	}
 
-	response := &PostObjectActionFreezeResponse{
+	response := &PostObjectActionSwitchResponse{
 		Body:         bodyBytes,
 		HTTPResponse: rsp,
 	}
@@ -16171,15 +17486,15 @@ func ParsePostObjectActionFreezeResponse(rsp *http.Response) (*PostObjectActionF
 	return response, nil
 }
 
-// ParsePostObjectActionGivebackResponse parses an HTTP response from a PostObjectActionGivebackWithResponse call
-func ParsePostObjectActionGivebackResponse(rsp *http.Response) (*PostObjectActionGivebackResponse, error) {
+// ParsePostObjectActionUnfreezeResponse parses an HTTP response from a PostObjectActionUnfreezeWithResponse call
+func ParsePostObjectActionUnfreezeResponse(rsp *http.Response) (*PostObjectActionUnfreezeResponse, error) {
 	bodyBytes, err := io.ReadAll(rsp.Body)
 	defer func() { _ = rsp.Body.Close() }()
 	if err != nil {
 		return nil, err
 	}
 
-	response := &PostObjectActionGivebackResponse{
+	response := &PostObjectActionUnfreezeResponse{
 		Body:         bodyBytes,
 		HTTPResponse: rsp,
 	}
@@ -16239,15 +17554,15 @@ func ParsePostObjectActionGivebackResponse(rsp *http.Response) (*PostObjectActio
 	return response, nil
 }
 
-// ParsePostObjectActionProvisionResponse parses an HTTP response from a PostObjectActionProvisionWithResponse call
-func ParsePostObjectActionProvisionResponse(rsp *http.Response) (*PostObjectActionProvisionResponse, error) {
+// ParsePostObjectActionUnprovisionResponse parses an HTTP response from a PostObjectActionUnprovisionWithResponse call
+func ParsePostObjectActionUnprovisionResponse(rsp *http.Response) (*PostObjectActionUnprovisionResponse, error) {
 	bodyBytes, err := io.ReadAll(rsp.Body)
 	defer func() { _ = rsp.Body.Close() }()
 	if err != nil {
 		return nil, err
 	}
 
-	response := &PostObjectActionProvisionResponse{
+	response := &PostObjectActionUnprovisionResponse{
 		Body:         bodyBytes,
 		HTTPResponse: rsp,
 	}
@@ -16307,22 +17622,22 @@ func ParsePostObjectActionProvisionResponse(rsp *http.Response) (*PostObjectActi
 	return response, nil
 }
 
-// ParsePostObjectActionPurgeResponse parses an HTTP response from a PostObjectActionPurgeWithResponse call
-func ParsePostObjectActionPurgeResponse(rsp *http.Response) (*PostObjectActionPurgeResponse, error) {
+// ParseGetObjectConfigResponse parses an HTTP response from a GetObjectConfigWithResponse call
+func ParseGetObjectConfigResponse(rsp *http.Response) (*GetObjectConfigResponse, error) {
 	bodyBytes, err := io.ReadAll(rsp.Body)
 	defer func() { _ = rsp.Body.Close() }()
 	if err != nil {
 		return nil, err
 	}
 
-	response := &PostObjectActionPurgeResponse{
+	response := &GetObjectConfigResponse{
 		Body:         bodyBytes,
 		HTTPResponse: rsp,
 	}
 
 	switch {
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
-		var dest OrchestrationQueued
+		var dest ObjectConfig
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
 			return nil, err
 		}
@@ -16349,20 +17664,6 @@ func ParsePostObjectActionPurgeResponse(rsp *http.Response) (*PostObjectActionPu
 		}
 		response.JSON403 = &dest
 
-	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 408:
-		var dest N408
-		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
-			return nil, err
-		}
-		response.JSON408 = &dest
-
-	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 409:
-		var dest N409
-		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
-			return nil, err
-		}
-		response.JSON409 = &dest
-
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 500:
 		var dest N500
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
@@ -16375,27 +17676,20 @@ func ParsePostObjectActionPurgeResponse(rsp *http.Response) (*PostObjectActionPu
 	return response, nil
 }
 
-// ParsePostObjectActionRestartResponse parses an HTTP response from a PostObjectActionRestartWithResponse call
-func ParsePostObjectActionRestartResponse(rsp *http.Response) (*PostObjectActionRestartResponse, error) {
+// ParseGetObjectConfigFileResponse parses an HTTP response from a GetObjectConfigFileWithResponse call
+func ParseGetObjectConfigFileResponse(rsp *http.Response) (*GetObjectConfigFileResponse, error) {
 	bodyBytes, err := io.ReadAll(rsp.Body)
 	defer func() { _ = rsp.Body.Close() }()
 	if err != nil {
 		return nil, err
 	}
 
-	response := &PostObjectActionRestartResponse{
+	response := &GetObjectConfigFileResponse{
 		Body:         bodyBytes,
 		HTTPResponse: rsp,
 	}
 
 	switch {
-	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
-		var dest OrchestrationQueued
-		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
-			return nil, err
-		}
-		response.JSON200 = &dest
-
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
 		var dest N400
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
@@ -16417,20 +17711,6 @@ func ParsePostObjectActionRestartResponse(rsp *http.Response) (*PostObjectAction
 		}
 		response.JSON403 = &dest
 
-	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 408:
-		var dest N408
-		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
-			return nil, err
-		}
-		response.JSON408 = &dest
-
-	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 409:
-		var dest N409
-		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
-			return nil, err
-		}
-		response.JSON409 = &dest
-
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 500:
 		var dest N500
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
@@ -16443,27 +17723,20 @@ func ParsePostObjectActionRestartResponse(rsp *http.Response) (*PostObjectAction
 	return response, nil
 }
 
-// ParsePostObjectActionStartResponse parses an HTTP response from a PostObjectActionStartWithResponse call
-func ParsePostObjectActionStartResponse(rsp *http.Response) (*PostObjectActionStartResponse, error) {
+// ParsePostObjectConfigFileResponse parses an HTTP response from a PostObjectConfigFileWithResponse call
+func ParsePostObjectConfigFileResponse(rsp *http.Response) (*PostObjectConfigFileResponse, error) {
 	bodyBytes, err := io.ReadAll(rsp.Body)
 	defer func() { _ = rsp.Body.Close() }()
 	if err != nil {
 		return nil, err
 	}
 
-	response := &PostObjectActionStartResponse{
+	response := &PostObjectConfigFileResponse{
 		Body:         bodyBytes,
 		HTTPResponse: rsp,
 	}
 
 	switch {
-	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
-		var dest OrchestrationQueued
-		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
-			return nil, err
-		}
-		response.JSON200 = &dest
-
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
 		var dest N400
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
@@ -16485,12 +17758,12 @@ func ParsePostObjectActionStartResponse(rsp *http.Response) (*PostObjectActionSt
 		}
 		response.JSON403 = &dest
 
-	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 408:
-		var dest N408
+	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
+		var dest N404
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
 			return nil, err
 		}
-		response.JSON408 = &dest
+		response.JSON404 = &dest
 
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 409:
 		var dest N409
@@ -16511,27 +17784,20 @@ func ParsePostObjectActionStartResponse(rsp *http.Response) (*PostObjectActionSt
 	return response, nil
 }
 
-// ParsePostObjectActionStopResponse parses an HTTP response from a PostObjectActionStopWithResponse call
-func ParsePostObjectActionStopResponse(rsp *http.Response) (*PostObjectActionStopResponse, error) {
+// ParsePutObjectConfigFileResponse parses an HTTP response from a PutObjectConfigFileWithResponse call
+func ParsePutObjectConfigFileResponse(rsp *http.Response) (*PutObjectConfigFileResponse, error) {
 	bodyBytes, err := io.ReadAll(rsp.Body)
 	defer func() { _ = rsp.Body.Close() }()
 	if err != nil {
 		return nil, err
 	}
 
-	response := &PostObjectActionStopResponse{
+	response := &PutObjectConfigFileResponse{
 		Body:         bodyBytes,
 		HTTPResponse: rsp,
 	}
 
 	switch {
-	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
-		var dest OrchestrationQueued
-		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
-			return nil, err
-		}
-		response.JSON200 = &dest
-
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
 		var dest N400
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
@@ -16553,12 +17819,12 @@ func ParsePostObjectActionStopResponse(rsp *http.Response) (*PostObjectActionSto
 		}
 		response.JSON403 = &dest
 
-	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 408:
-		var dest N408
+	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
+		var dest N404
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
 			return nil, err
 		}
-		response.JSON408 = &dest
+		response.JSON404 = &dest
 
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 409:
 		var dest N409
@@ -16579,22 +17845,22 @@ func ParsePostObjectActionStopResponse(rsp *http.Response) (*PostObjectActionSto
 	return response, nil
 }
 
-// ParsePostObjectActionSwitchResponse parses an HTTP response from a PostObjectActionSwitchWithResponse call
-func ParsePostObjectActionSwitchResponse(rsp *http.Response) (*PostObjectActionSwitchResponse, error) {
+// ParseGetObjectConfigGetResponse parses an HTTP response from a GetObjectConfigGetWithResponse call
+func ParseGetObjectConfigGetResponse(rsp *http.Response) (*GetObjectConfigGetResponse, error) {
 	bodyBytes, err := io.ReadAll(rsp.Body)
 	defer func() { _ = rsp.Body.Close() }()
 	if err != nil {
 		return nil, err
 	}
 
-	response := &PostObjectActionSwitchResponse{
+	response := &GetObjectConfigGetResponse{
 		Body:         bodyBytes,
 		HTTPResponse: rsp,
 	}
 
 	switch {
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
-		var dest OrchestrationQueued
+		var dest KeywordList
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
 			return nil, err
 		}
@@ -16621,20 +17887,6 @@ func ParsePostObjectActionSwitchResponse(rsp *http.Response) (*PostObjectActionS
 		}
 		response.JSON403 = &dest
 
-	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 408:
-		var dest N408
-		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
-			return nil, err
-		}
-		response.JSON408 = &dest
-
-	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 409:
-		var dest N409
-		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
-			return nil, err
-		}
-		response.JSON409 = &dest
-
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 500:
 		var dest N500
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
@@ -16647,27 +17899,20 @@ func ParsePostObjectActionSwitchResponse(rsp *http.Response) (*PostObjectActionS
 	return response, nil
 }
 
-// ParsePostObjectActionUnfreezeResponse parses an HTTP response from a PostObjectActionUnfreezeWithResponse call
-func ParsePostObjectActionUnfreezeResponse(rsp *http.Response) (*PostObjectActionUnfreezeResponse, error) {
+// ParsePostObjectConfigUpdateResponse parses an HTTP response from a PostObjectConfigUpdateWithResponse call
+func ParsePostObjectConfigUpdateResponse(rsp *http.Response) (*PostObjectConfigUpdateResponse, error) {
 	bodyBytes, err := io.ReadAll(rsp.Body)
 	defer func() { _ = rsp.Body.Close() }()
 	if err != nil {
 		return nil, err
 	}
 
-	response := &PostObjectActionUnfreezeResponse{
+	response := &PostObjectConfigUpdateResponse{
 		Body:         bodyBytes,
 		HTTPResponse: rsp,
 	}
 
 	switch {
-	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
-		var dest OrchestrationQueued
-		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
-			return nil, err
-		}
-		response.JSON200 = &dest
-
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
 		var dest N400
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
@@ -16689,20 +17934,6 @@ func ParsePostObjectActionUnfreezeResponse(rsp *http.Response) (*PostObjectActio
 		}
 		response.JSON403 = &dest
 
-	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 408:
-		var dest N408
-		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
-			return nil, err
-		}
-		response.JSON408 = &dest
-
-	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 409:
-		var dest N409
-		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
-			return nil, err
-		}
-		response.JSON409 = &dest
-
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 500:
 		var dest N500
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
@@ -16715,22 +17946,22 @@ func ParsePostObjectActionUnfreezeResponse(rsp *http.Response) (*PostObjectActio
 	return response, nil
 }
 
-// ParsePostObjectActionUnprovisionResponse parses an HTTP response from a PostObjectActionUnprovisionWithResponse call
-func ParsePostObjectActionUnprovisionResponse(rsp *http.Response) (*PostObjectActionUnprovisionResponse, error) {
+// ParseGetObjectKVStoreResponse parses an HTTP response from a GetObjectKVStoreWithResponse call
+func ParseGetObjectKVStoreResponse(rsp *http.Response) (*GetObjectKVStoreResponse, error) {
 	bodyBytes, err := io.ReadAll(rsp.Body)
 	defer func() { _ = rsp.Body.Close() }()
 	if err != nil {
 		return nil, err
 	}
 
-	response := &PostObjectActionUnprovisionResponse{
+	response := &GetObjectKVStoreResponse{
 		Body:         bodyBytes,
 		HTTPResponse: rsp,
 	}
 
 	switch {
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
-		var dest OrchestrationQueued
+		var dest KVStoreEntries
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
 			return nil, err
 		}
@@ -16757,20 +17988,6 @@ func ParsePostObjectActionUnprovisionResponse(rsp *http.Response) (*PostObjectAc
 		}
 		response.JSON403 = &dest
 
-	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 408:
-		var dest N408
-		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
-			return nil, err
-		}
-		response.JSON408 = &dest
-
-	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 409:
-		var dest N409
-		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
-			return nil, err
-		}
-		response.JSON409 = &dest
-
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 500:
 		var dest N500
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
@@ -16783,27 +18000,20 @@ func ParsePostObjectActionUnprovisionResponse(rsp *http.Response) (*PostObjectAc
 	return response, nil
 }
 
-// ParseGetObjectConfigResponse parses an HTTP response from a GetObjectConfigWithResponse call
-func ParseGetObjectConfigResponse(rsp *http.Response) (*GetObjectConfigResponse, error) {
+// ParsePatchObjectKVStoreResponse parses an HTTP response from a PatchObjectKVStoreWithResponse call
+func ParsePatchObjectKVStoreResponse(rsp *http.Response) (*PatchObjectKVStoreResponse, error) {
 	bodyBytes, err := io.ReadAll(rsp.Body)
 	defer func() { _ = rsp.Body.Close() }()
 	if err != nil {
 		return nil, err
 	}
 
-	response := &GetObjectConfigResponse{
+	response := &PatchObjectKVStoreResponse{
 		Body:         bodyBytes,
 		HTTPResponse: rsp,
 	}
 
 	switch {
-	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
-		var dest ObjectConfig
-		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
-			return nil, err
-		}
-		response.JSON200 = &dest
-
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
 		var dest N400
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
@@ -16825,6 +18035,20 @@ func ParseGetObjectConfigResponse(rsp *http.Response) (*GetObjectConfigResponse,
 		}
 		response.JSON403 = &dest
 
+	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 408:
+		var dest N408
+		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
+			return nil, err
+		}
+		response.JSON408 = &dest
+
+	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 409:
+		var dest N409
+		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
+			return nil, err
+		}
+		response.JSON409 = &dest
+
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 500:
 		var dest N500
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
@@ -16837,15 +18061,15 @@ func ParseGetObjectConfigResponse(rsp *http.Response) (*GetObjectConfigResponse,
 	return response, nil
 }
 
-// ParseGetObjectConfigFileResponse parses an HTTP response from a GetObjectConfigFileWithResponse call
-func ParseGetObjectConfigFileResponse(rsp *http.Response) (*GetObjectConfigFileResponse, error) {
+// ParseDeleteObjectKVStoreEntryResponse parses an HTTP response from a DeleteObjectKVStoreEntryWithResponse call
+func ParseDeleteObjectKVStoreEntryResponse(rsp *http.Response) (*DeleteObjectKVStoreEntryResponse, error) {
 	bodyBytes, err := io.ReadAll(rsp.Body)
 	defer func() { _ = rsp.Body.Close() }()
 	if err != nil {
 		return nil, err
 	}
 
-	response := &GetObjectConfigFileResponse{
+	response := &DeleteObjectKVStoreEntryResponse{
 		Body:         bodyBytes,
 		HTTPResponse: rsp,
 	}
@@ -16884,15 +18108,15 @@ func ParseGetObjectConfigFileResponse(rsp *http.Response) (*GetObjectConfigFileR
 	return response, nil
 }
 
-// ParsePostObjectConfigFileResponse parses an HTTP response from a PostObjectConfigFileWithResponse call
-func ParsePostObjectConfigFileResponse(rsp *http.Response) (*PostObjectConfigFileResponse, error) {
+// ParseGetObjectKVStoreEntryResponse parses an HTTP response from a GetObjectKVStoreEntryWithResponse call
+func ParseGetObjectKVStoreEntryResponse(rsp *http.Response) (*GetObjectKVStoreEntryResponse, error) {
 	bodyBytes, err := io.ReadAll(rsp.Body)
 	defer func() { _ = rsp.Body.Close() }()
 	if err != nil {
 		return nil, err
 	}
 
-	response := &PostObjectConfigFileResponse{
+	response := &GetObjectKVStoreEntryResponse{
 		Body:         bodyBytes,
 		HTTPResponse: rsp,
 	}
@@ -16919,20 +18143,6 @@ func ParsePostObjectConfigFileResponse(rsp *http.Response) (*PostObjectConfigFil
 		}
 		response.JSON403 = &dest
 
-	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
-		var dest N404
-		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
-			return nil, err
-		}
-		response.JSON404 = &dest
-
-	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 409:
-		var dest N409
-		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
-			return nil, err
-		}
-		response.JSON409 = &dest
-
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 500:
 		var dest N500
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
@@ -16945,15 +18155,15 @@ func ParsePostObjectConfigFileResponse(rsp *http.Response) (*PostObjectConfigFil
 	return response, nil
 }
 
-// ParsePutObjectConfigFileResponse parses an HTTP response from a PutObjectConfigFileWithResponse call
-func ParsePutObjectConfigFileResponse(rsp *http.Response) (*PutObjectConfigFileResponse, error) {
+// ParsePostObjectKVStoreEntryResponse parses an HTTP response from a PostObjectKVStoreEntryWithResponse call
+func ParsePostObjectKVStoreEntryResponse(rsp *http.Response) (*PostObjectKVStoreEntryResponse, error) {
 	bodyBytes, err := io.ReadAll(rsp.Body)
 	defer func() { _ = rsp.Body.Close() }()
 	if err != nil {
 		return nil, err
 	}
 
-	response := &PutObjectConfigFileResponse{
+	response := &PostObjectKVStoreEntryResponse{
 		Body:         bodyBytes,
 		HTTPResponse: rsp,
 	}
@@ -16980,20 +18190,6 @@ func ParsePutObjectConfigFileResponse(rsp *http.Response) (*PutObjectConfigFileR
 		}
 		response.JSON403 = &dest
 
-	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
-		var dest N404
-		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
-			return nil, err
-		}
-		response.JSON404 = &dest
-
-	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 409:
-		var dest N409
-		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
-			return nil, err
-		}
-		response.JSON409 = &dest
-
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 500:
 		var dest N500
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
@@ -17006,27 +18202,20 @@ func ParsePutObjectConfigFileResponse(rsp *http.Response) (*PutObjectConfigFileR
 	return response, nil
 }
 
-// ParseGetObjectConfigGetResponse parses an HTTP response from a GetObjectConfigGetWithResponse call
-func ParseGetObjectConfigGetResponse(rsp *http.Response) (*GetObjectConfigGetResponse, error) {
+// ParsePutObjectKVStoreEntryResponse parses an HTTP response from a PutObjectKVStoreEntryWithResponse call
+func ParsePutObjectKVStoreEntryResponse(rsp *http.Response) (*PutObjectKVStoreEntryResponse, error) {
 	bodyBytes, err := io.ReadAll(rsp.Body)
 	defer func() { _ = rsp.Body.Close() }()
 	if err != nil {
 		return nil, err
 	}
 
-	response := &GetObjectConfigGetResponse{
+	response := &PutObjectKVStoreEntryResponse{
 		Body:         bodyBytes,
 		HTTPResponse: rsp,
 	}
 
 	switch {
-	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
-		var dest KeywordList
-		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
-			return nil, err
-		}
-		response.JSON200 = &dest
-
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
 		var dest N400
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
@@ -17060,20 +18249,27 @@ func ParseGetObjectConfigGetResponse(rsp *http.Response) (*GetObjectConfigGetRes
 	return response, nil
 }
 
-// ParsePostObjectConfigUpdateResponse parses an HTTP response from a PostObjectConfigUpdateWithResponse call
-func ParsePostObjectConfigUpdateResponse(rsp *http.Response) (*PostObjectConfigUpdateResponse, error) {
+// ParseGetObjectKVStoreKeysResponse parses an HTTP response from a GetObjectKVStoreKeysWithResponse call
+func ParseGetObjectKVStoreKeysResponse(rsp *http.Response) (*GetObjectKVStoreKeysResponse, error) {
 	bodyBytes, err := io.ReadAll(rsp.Body)
 	defer func() { _ = rsp.Body.Close() }()
 	if err != nil {
 		return nil, err
 	}
 
-	response := &PostObjectConfigUpdateResponse{
+	response := &GetObjectKVStoreKeysResponse{
 		Body:         bodyBytes,
 		HTTPResponse: rsp,
 	}
 
 	switch {
+	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
+		var dest KVStoreKeyList
+		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
+			return nil, err
+		}
+		response.JSON200 = &dest
+
 	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
 		var dest N400
 		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
diff --git a/daemon/api/codegen_server_gen.go b/daemon/api/codegen_server_gen.go
index a77a47c2b..b17e7816e 100644
--- a/daemon/api/codegen_server_gen.go
+++ b/daemon/api/codegen_server_gen.go
@@ -303,6 +303,27 @@ type ServerInterface interface {
 	// (POST /object/path/{namespace}/{kind}/{name}/config/update)
 	PostObjectConfigUpdate(ctx echo.Context, namespace InPathNamespace, kind InPathKind, name InPathName, params PostObjectConfigUpdateParams) error
 
+	// (GET /object/path/{namespace}/{kind}/{name}/kvstore)
+	GetObjectKVStore(ctx echo.Context, namespace InPathNamespace, kind InPathKind, name InPathName, params GetObjectKVStoreParams) error
+
+	// (PATCH /object/path/{namespace}/{kind}/{name}/kvstore)
+	PatchObjectKVStore(ctx echo.Context, namespace InPathNamespace, kind InPathKind, name InPathName) error
+
+	// (DELETE /object/path/{namespace}/{kind}/{name}/kvstore/entry)
+	DeleteObjectKVStoreEntry(ctx echo.Context, namespace InPathNamespace, kind InPathKind, name InPathName, params DeleteObjectKVStoreEntryParams) error
+
+	// (GET /object/path/{namespace}/{kind}/{name}/kvstore/entry)
+	GetObjectKVStoreEntry(ctx echo.Context, namespace InPathNamespace, kind InPathKind, name InPathName, params GetObjectKVStoreEntryParams) error
+
+	// (POST /object/path/{namespace}/{kind}/{name}/kvstore/entry)
+	PostObjectKVStoreEntry(ctx echo.Context, namespace InPathNamespace, kind InPathKind, name InPathName, params PostObjectKVStoreEntryParams) error
+
+	// (PUT /object/path/{namespace}/{kind}/{name}/kvstore/entry)
+	PutObjectKVStoreEntry(ctx echo.Context, namespace InPathNamespace, kind InPathKind, name InPathName, params PutObjectKVStoreEntryParams) error
+
+	// (GET /object/path/{namespace}/{kind}/{name}/kvstore/keys)
+	GetObjectKVStoreKeys(ctx echo.Context, namespace InPathNamespace, kind InPathKind, name InPathName) error
+
 	// (GET /pool)
 	GetPools(ctx echo.Context, params GetPoolsParams) error
 
@@ -3768,6 +3789,303 @@ func (w *ServerInterfaceWrapper) PostObjectConfigUpdate(ctx echo.Context) error
 	return err
 }
 
+// GetObjectKVStore converts echo context to params.
+func (w *ServerInterfaceWrapper) GetObjectKVStore(ctx echo.Context) error {
+	var err error
+	// ------------- Path parameter "namespace" -------------
+	var namespace InPathNamespace
+
+	err = runtime.BindStyledParameterWithLocation("simple", false, "namespace", runtime.ParamLocationPath, ctx.Param("namespace"), &namespace)
+	if err != nil {
+		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter namespace: %s", err))
+	}
+
+	// ------------- Path parameter "kind" -------------
+	var kind InPathKind
+
+	err = runtime.BindStyledParameterWithLocation("simple", false, "kind", runtime.ParamLocationPath, ctx.Param("kind"), &kind)
+	if err != nil {
+		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter kind: %s", err))
+	}
+
+	// ------------- Path parameter "name" -------------
+	var name InPathName
+
+	err = runtime.BindStyledParameterWithLocation("simple", false, "name", runtime.ParamLocationPath, ctx.Param("name"), &name)
+	if err != nil {
+		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter name: %s", err))
+	}
+
+	ctx.Set(BasicAuthScopes, []string{})
+
+	ctx.Set(BearerAuthScopes, []string{})
+
+	// Parameter object where we will unmarshal all parameters from the context
+	var params GetObjectKVStoreParams
+	// ------------- Optional query parameter "key" -------------
+
+	err = runtime.BindQueryParameter("form", true, false, "key", ctx.QueryParams(), &params.Keys)
+	if err != nil {
+		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter key: %s", err))
+	}
+
+	// Invoke the callback with all the unmarshaled arguments
+	err = w.Handler.GetObjectKVStore(ctx, namespace, kind, name, params)
+	return err
+}
+
+// PatchObjectKVStore converts echo context to params.
+func (w *ServerInterfaceWrapper) PatchObjectKVStore(ctx echo.Context) error {
+	var err error
+	// ------------- Path parameter "namespace" -------------
+	var namespace InPathNamespace
+
+	err = runtime.BindStyledParameterWithLocation("simple", false, "namespace", runtime.ParamLocationPath, ctx.Param("namespace"), &namespace)
+	if err != nil {
+		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter namespace: %s", err))
+	}
+
+	// ------------- Path parameter "kind" -------------
+	var kind InPathKind
+
+	err = runtime.BindStyledParameterWithLocation("simple", false, "kind", runtime.ParamLocationPath, ctx.Param("kind"), &kind)
+	if err != nil {
+		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter kind: %s", err))
+	}
+
+	// ------------- Path parameter "name" -------------
+	var name InPathName
+
+	err = runtime.BindStyledParameterWithLocation("simple", false, "name", runtime.ParamLocationPath, ctx.Param("name"), &name)
+	if err != nil {
+		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter name: %s", err))
+	}
+
+	ctx.Set(BasicAuthScopes, []string{})
+
+	ctx.Set(BearerAuthScopes, []string{})
+
+	// Invoke the callback with all the unmarshaled arguments
+	err = w.Handler.PatchObjectKVStore(ctx, namespace, kind, name)
+	return err
+}
+
+// DeleteObjectKVStoreEntry converts echo context to params.
+func (w *ServerInterfaceWrapper) DeleteObjectKVStoreEntry(ctx echo.Context) error {
+	var err error
+	// ------------- Path parameter "namespace" -------------
+	var namespace InPathNamespace
+
+	err = runtime.BindStyledParameterWithLocation("simple", false, "namespace", runtime.ParamLocationPath, ctx.Param("namespace"), &namespace)
+	if err != nil {
+		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter namespace: %s", err))
+	}
+
+	// ------------- Path parameter "kind" -------------
+	var kind InPathKind
+
+	err = runtime.BindStyledParameterWithLocation("simple", false, "kind", runtime.ParamLocationPath, ctx.Param("kind"), &kind)
+	if err != nil {
+		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter kind: %s", err))
+	}
+
+	// ------------- Path parameter "name" -------------
+	var name InPathName
+
+	err = runtime.BindStyledParameterWithLocation("simple", false, "name", runtime.ParamLocationPath, ctx.Param("name"), &name)
+	if err != nil {
+		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter name: %s", err))
+	}
+
+	ctx.Set(BasicAuthScopes, []string{})
+
+	ctx.Set(BearerAuthScopes, []string{})
+
+	// Parameter object where we will unmarshal all parameters from the context
+	var params DeleteObjectKVStoreEntryParams
+	// ------------- Required query parameter "key" -------------
+
+	err = runtime.BindQueryParameter("form", true, true, "key", ctx.QueryParams(), &params.Key)
+	if err != nil {
+		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter key: %s", err))
+	}
+
+	// Invoke the callback with all the unmarshaled arguments
+	err = w.Handler.DeleteObjectKVStoreEntry(ctx, namespace, kind, name, params)
+	return err
+}
+
+// GetObjectKVStoreEntry converts echo context to params.
+func (w *ServerInterfaceWrapper) GetObjectKVStoreEntry(ctx echo.Context) error {
+	var err error
+	// ------------- Path parameter "namespace" -------------
+	var namespace InPathNamespace
+
+	err = runtime.BindStyledParameterWithLocation("simple", false, "namespace", runtime.ParamLocationPath, ctx.Param("namespace"), &namespace)
+	if err != nil {
+		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter namespace: %s", err))
+	}
+
+	// ------------- Path parameter "kind" -------------
+	var kind InPathKind
+
+	err = runtime.BindStyledParameterWithLocation("simple", false, "kind", runtime.ParamLocationPath, ctx.Param("kind"), &kind)
+	if err != nil {
+		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter kind: %s", err))
+	}
+
+	// ------------- Path parameter "name" -------------
+	var name InPathName
+
+	err = runtime.BindStyledParameterWithLocation("simple", false, "name", runtime.ParamLocationPath, ctx.Param("name"), &name)
+	if err != nil {
+		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter name: %s", err))
+	}
+
+	ctx.Set(BasicAuthScopes, []string{})
+
+	ctx.Set(BearerAuthScopes, []string{})
+
+	// Parameter object where we will unmarshal all parameters from the context
+	var params GetObjectKVStoreEntryParams
+	// ------------- Required query parameter "key" -------------
+
+	err = runtime.BindQueryParameter("form", true, true, "key", ctx.QueryParams(), &params.Key)
+	if err != nil {
+		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter key: %s", err))
+	}
+
+	// Invoke the callback with all the unmarshaled arguments
+	err = w.Handler.GetObjectKVStoreEntry(ctx, namespace, kind, name, params)
+	return err
+}
+
+// PostObjectKVStoreEntry converts echo context to params.
+func (w *ServerInterfaceWrapper) PostObjectKVStoreEntry(ctx echo.Context) error {
+	var err error
+	// ------------- Path parameter "namespace" -------------
+	var namespace InPathNamespace
+
+	err = runtime.BindStyledParameterWithLocation("simple", false, "namespace", runtime.ParamLocationPath, ctx.Param("namespace"), &namespace)
+	if err != nil {
+		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter namespace: %s", err))
+	}
+
+	// ------------- Path parameter "kind" -------------
+	var kind InPathKind
+
+	err = runtime.BindStyledParameterWithLocation("simple", false, "kind", runtime.ParamLocationPath, ctx.Param("kind"), &kind)
+	if err != nil {
+		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter kind: %s", err))
+	}
+
+	// ------------- Path parameter "name" -------------
+	var name InPathName
+
+	err = runtime.BindStyledParameterWithLocation("simple", false, "name", runtime.ParamLocationPath, ctx.Param("name"), &name)
+	if err != nil {
+		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter name: %s", err))
+	}
+
+	ctx.Set(BasicAuthScopes, []string{})
+
+	ctx.Set(BearerAuthScopes, []string{})
+
+	// Parameter object where we will unmarshal all parameters from the context
+	var params PostObjectKVStoreEntryParams
+	// ------------- Required query parameter "key" -------------
+
+	err = runtime.BindQueryParameter("form", true, true, "key", ctx.QueryParams(), &params.Key)
+	if err != nil {
+		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter key: %s", err))
+	}
+
+	// Invoke the callback with all the unmarshaled arguments
+	err = w.Handler.PostObjectKVStoreEntry(ctx, namespace, kind, name, params)
+	return err
+}
+
+// PutObjectKVStoreEntry converts echo context to params.
+func (w *ServerInterfaceWrapper) PutObjectKVStoreEntry(ctx echo.Context) error {
+	var err error
+	// ------------- Path parameter "namespace" -------------
+	var namespace InPathNamespace
+
+	err = runtime.BindStyledParameterWithLocation("simple", false, "namespace", runtime.ParamLocationPath, ctx.Param("namespace"), &namespace)
+	if err != nil {
+		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter namespace: %s", err))
+	}
+
+	// ------------- Path parameter "kind" -------------
+	var kind InPathKind
+
+	err = runtime.BindStyledParameterWithLocation("simple", false, "kind", runtime.ParamLocationPath, ctx.Param("kind"), &kind)
+	if err != nil {
+		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter kind: %s", err))
+	}
+
+	// ------------- Path parameter "name" -------------
+	var name InPathName
+
+	err = runtime.BindStyledParameterWithLocation("simple", false, "name", runtime.ParamLocationPath, ctx.Param("name"), &name)
+	if err != nil {
+		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter name: %s", err))
+	}
+
+	ctx.Set(BasicAuthScopes, []string{})
+
+	ctx.Set(BearerAuthScopes, []string{})
+
+	// Parameter object where we will unmarshal all parameters from the context
+	var params PutObjectKVStoreEntryParams
+	// ------------- Required query parameter "key" -------------
+
+	err = runtime.BindQueryParameter("form", true, true, "key", ctx.QueryParams(), &params.Key)
+	if err != nil {
+		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter key: %s", err))
+	}
+
+	// Invoke the callback with all the unmarshaled arguments
+	err = w.Handler.PutObjectKVStoreEntry(ctx, namespace, kind, name, params)
+	return err
+}
+
+// GetObjectKVStoreKeys converts echo context to params.
+func (w *ServerInterfaceWrapper) GetObjectKVStoreKeys(ctx echo.Context) error {
+	var err error
+	// ------------- Path parameter "namespace" -------------
+	var namespace InPathNamespace
+
+	err = runtime.BindStyledParameterWithLocation("simple", false, "namespace", runtime.ParamLocationPath, ctx.Param("namespace"), &namespace)
+	if err != nil {
+		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter namespace: %s", err))
+	}
+
+	// ------------- Path parameter "kind" -------------
+	var kind InPathKind
+
+	err = runtime.BindStyledParameterWithLocation("simple", false, "kind", runtime.ParamLocationPath, ctx.Param("kind"), &kind)
+	if err != nil {
+		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter kind: %s", err))
+	}
+
+	// ------------- Path parameter "name" -------------
+	var name InPathName
+
+	err = runtime.BindStyledParameterWithLocation("simple", false, "name", runtime.ParamLocationPath, ctx.Param("name"), &name)
+	if err != nil {
+		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter name: %s", err))
+	}
+
+	ctx.Set(BasicAuthScopes, []string{})
+
+	ctx.Set(BearerAuthScopes, []string{})
+
+	// Invoke the callback with all the unmarshaled arguments
+	err = w.Handler.GetObjectKVStoreKeys(ctx, namespace, kind, name)
+	return err
+}
+
 // GetPools converts echo context to params.
 func (w *ServerInterfaceWrapper) GetPools(ctx echo.Context) error {
 	var err error
@@ -4034,6 +4352,13 @@ func RegisterHandlersWithBaseURL(router EchoRouter, si ServerInterface, baseURL
 	router.PUT(baseURL+"/object/path/:namespace/:kind/:name/config/file", wrapper.PutObjectConfigFile)
 	router.GET(baseURL+"/object/path/:namespace/:kind/:name/config/get", wrapper.GetObjectConfigGet)
 	router.POST(baseURL+"/object/path/:namespace/:kind/:name/config/update", wrapper.PostObjectConfigUpdate)
+	router.GET(baseURL+"/object/path/:namespace/:kind/:name/kvstore", wrapper.GetObjectKVStore)
+	router.PATCH(baseURL+"/object/path/:namespace/:kind/:name/kvstore", wrapper.PatchObjectKVStore)
+	router.DELETE(baseURL+"/object/path/:namespace/:kind/:name/kvstore/entry", wrapper.DeleteObjectKVStoreEntry)
+	router.GET(baseURL+"/object/path/:namespace/:kind/:name/kvstore/entry", wrapper.GetObjectKVStoreEntry)
+	router.POST(baseURL+"/object/path/:namespace/:kind/:name/kvstore/entry", wrapper.PostObjectKVStoreEntry)
+	router.PUT(baseURL+"/object/path/:namespace/:kind/:name/kvstore/entry", wrapper.PutObjectKVStoreEntry)
+	router.GET(baseURL+"/object/path/:namespace/:kind/:name/kvstore/keys", wrapper.GetObjectKVStoreKeys)
 	router.GET(baseURL+"/pool", wrapper.GetPools)
 	router.GET(baseURL+"/pool/volume", wrapper.GetPoolVolumes)
 	router.GET(baseURL+"/public/openapi", wrapper.GetSwagger)
@@ -4047,198 +4372,203 @@ func RegisterHandlersWithBaseURL(router EchoRouter, si ServerInterface, baseURL
 // Base64 encoded, gzipped, json marshaled Swagger object
 var swaggerSpec = []string{
 
-	"H4sIAAAAAAAC/+x9e3Mbt5LvV0HxbFWSvdTLdrKJb6W2HCvJ8Ylj60j2btWJfFXgTJPE0QwwATCUlJS+",
-	"+y285gkMZ0jqEXn+iSMOHo3GrxuNRqPx5yRiacYoUCkmL/+cZJjjFCRw/dfx6Q/Hrxmdk8U7nIL6JQYR",
-	"cZJJwujk5UQuAc3zJEEZlkvE5kj/QBJARKAY4jyCGM05S/UHqtqYToiq+XsO/GYynejfXk7sJw6/54RD",
-	"PHkpeQ7TiYiWkGLVr7zJVDkhOaGLye3tdHKcc2zIaFKV4msUu6/+/iqfyz7gGqdZoj5/LSZTT5c/rnCS",
-	"Y+lhBLgv/u4qn1tDmjGWAKa2A6DyJ5JI4O0+EiKk4jGoQorLqpS/v+Jj2RuRkIp2o6YkguuMgxCE0Zfo",
-	"t0tC40+/TRM8g+R7RTl8+s9zxaqSQe9n/4ZInkksc/Exi7GEeKow8P2csTbrih8w5/hGj/RNmgEXjHq5",
-	"ScqPGjiWfYRRhAWiLA7xuVJx0o2etyQl0sfjlEikeYUillMZ6EiX84PnaDqZM55iqeih8psXJT8IlbAA",
-	"bghgi3UTnbDFrqYZI89EVya4Ptv7+/u12RYk/v47/C0cvoBv9mbR0bO9F8/hm71vn8dHe3M4Ooy/fv7N",
-	"c8D/1Wvm1cBZkrArDxj173rKE7YQoVGb2mtE6S1bvCUUPLzgkDEukVwSgWiezoArZmdYSJTo/7AFAio5",
-	"ARGcfaq/tQioTrDSmCLDEbzXHeOkTQl1RTq0ovveBeZ3LO7qhcWABCQQSVYFwH6oVyNfPr1In03xH99D",
-	"fuRVjydYLtvdM60qhhCgFEnnYlASFM+Oplcw+88gPWG2bEzXRnSIsJhbQlTrAkmGBNBY4x/NGe8gRfQR",
-	"/ErjdZFeRUdTJFbRs15CewoJvnmd5EICf3PsNwQi8xmRGBU2hbMJRMKk+sCo/pOr5gJDs81ckLgL9dPJ",
-	"9d6C7dk6JWWOViUSNGizUPt1K0JdI2uE85TEYRByECzn0SD5dHUCUJyLvx1NSeZF4ilLoAOJOCOIsySk",
-	"juwnD+b+g8N88nLyt4PSmDwwxcSB6tOLqTM75DB3HFMC9FQ+d00AoUoAfyE01jTTUpJtO8re6dQ3XcPT",
-	"7ZbdODvZ080GNm7ZplkGwg27ZaKP0pQgpBcetjsWQ9cwStj36SxhEU6WLNjjP9WcHkMC0iDTa63rz33U",
-	"3Qe7zdBoRgIibTRKhkwTU3RF5JLlEs04ji5BirqhI7G4/FtOrzCVEPdSjG4AROBZAqcsSWY4ugwOxBS7",
-	"4K7cGiPGtl7dd/TeXtQZcwwc5sCBRjBFImIZIEyVoqYr0MYQoEu4uWI8RhxfIW0H7pcc8BD1E+NRkKI5",
-	"4xH0HF1jKzDErvdMvjJ2NAIkQ9V9xNUSaLGRoAuE3Xj30RlI/VOtuMWJY+33CuGIg8w5FQijH3CMTuH3",
-	"HIREwDnj+134/sV0FQT45VUfcL8qpkgyxCFlK6jDF+hqfxP0vgUcm42I19o1X/tNpuUJ8DMShxrkrsyF",
-	"aCzyxcYpz0l7BPU1v+zJLJdq8a/Q0dF9p2XR6KTe6hnI4BwKkMMmkWVgnBBuzYdYbW/P88PD59Hllf4X",
-	"fjN/EhrDtfnlk/mFZeZP85eWV/OD0XGIZSghl4C+R//ne7T3fRsogOX3c54TKYZA5SyfqYGGeGC+rlvU",
-	"dEsf8CLUjMSLnm2wYBOsXwsfqeiY05z2nNXquqPNyHLlMYK665XnVq2+ImNUmGXz2eGh+idiVALV84Oz",
-	"LCGRBtjBv4Xxk/UzaU44myWQml7q43z/i6Ll2eGLNgveMfTa9n47nby4H3oqatj0enQfvX6kOJdLxskf",
-	"EJtun99Htz8xPiNxDNT0+eI++nzHJPqJ5dSO89v76NOtqx9ICiy3E/vdffT8mtF5QiLd5df3g+A3VAKn",
-	"OEFnwFfA0Y/KmDD93wuoVLckAvSR4hUmiTJPtX60VVXLr/iMSI4l48bhq88JuFq+JDHaRxS/d1Fha99O",
-	"JzlP/Fq53FH8pgtNXdOfCg1oPBqqlVe5XL6hc9amJwW5ZNbccgobaJ6qZlkGVFsAMyxIpNb7rw+/Ux0Z",
-	"M6LSU0j5Tl0brX6jhACVF+ZTq5UrSJKLS8qu6EXOyXoGNMpPK81/apZ1Iw7x6QO7BNomGK4z1cIFljXz",
-	"K8YS9iTRm7w2M1xT3dRXmnZ1fMS9xhmekYTImzZ1zoHT3ZEu1d30Gwlpu/kYy7WSUyHvdmo8BRUsNXrw",
-	"QSeF9Z2oHfevqlxzaNYzoduYGnrXD1T0ds00yPcAvSzxlgjZZuEG3YhuRup+Pk3XzLlljOneyxLjEfSI",
-	"qD7OXEuyqW7OPlV72iner5KaTa0kDDH9Kr0vKO+nS201p1Ib7LGDnDpfviWlU5vWh1xKXavEO8uK0Pf3",
-	"xbhDJcplpF2CpSmRygZuY01ES0wXEAd2oFUGlGV9Qz1+d3YKEeNeDY6F8Gpvpy1aHwJaajqRMvGdDTmC",
-	"euk1W3hqCTONdqiC43dn/2IUestmyQqP9B+f/nD8KklYVBy0b796mLVxyEbfePVTQhn3szNjXAYO4ar8",
-	"1MVcQ9P6+kQCQCniH8KrRzGU2Y2EyTrFFZ44DCmjb1lkHOGNhbBymtHiKGe5dCeda1hQ9d26WmFiTnwm",
-	"TlYzboK8DjFUNxwyI6NSaffQfUYoVXtrQV7hbUtV2saKtrxkE3HpQQCsMnvkGYB5D1izGBL/tMKCMNp/",
-	"lT3V5X1iLMgfUBe6UFxCUDVNJyugcU0AAwDX4uw4Y/suarvxFlrNDTLE9M0NNz1lHkujaPWujDVNnG2q",
-	"a1j9Z7Yg2aeiibjcwjQriQmwakfm2DEnK581tqWFb5rdAiSGLN/Y9RfxsEgpRjdgQkuO+NCiv26DlwpJ",
-	"Ya7tCDQ6Gs4R2zo3177PoggiAmHkDrKFUMqlXJkJxdqt25rGnznLMw8vfGucT333w6/WiUEQaxo2x7AZ",
-	"gmcyynYfCsAFBf0BVhLtga/+uAV6K/SE+LUj6P4d8/gKcxi0wagi3Pe90KGtT0EzpN9Ow67VVQLKDYft",
-	"1rbVNdjNMVywyzMttdYfCslVIvrjrUa6B8/u+xaQrhPWwb4dAfvNyas45iA81jsuP7TmaJ7gRQwZhwhL",
-	"7wa+rlx/SvDiuCyuj+vk3NtyiqPA78Zk31AkVLPTYkitAViCbDcdslHwa3PhKFnumd56+w8lHjUq+oO3",
-	"TrxHQIoCW0hIgzYfD4+rvexARqiQmEawqfPR1S+9jymjRDLet+Kvtnhvb6KrWHEnBkf1Sp9sv4oiyLxu",
-	"OnuOcjHc0VMP5KiyvNJmF8NDrhqcZV5VEC0huhR5GvhIkpibk44CaGtPhmKe+dyT0wnQVUAzwvVFiq/9",
-	"ri3zldCOrxLzBUh/AYubCxwFrYpO1xLj0RKE5DY0qwtC7ytFtUXC3ZWi/swLmjFZgiNIgcqLjCUkull7",
-	"3unKn5ji2knI/H6WjMNFDz5lnDBuT6najHYxuW4hJCak9aQGw27vjWmglPkWynXU3jCGtjw/YcePCd1Z",
-	"f4ZrilXIZBlL2GLtlHxw5W6nk9zcGBrgN27oAyXQFfGtCKuRQCNuFeGqSFJdbFoy4gXEtOo5rQrF1NnO",
-	"Du8erFawUwWKm9CS9RVm1njUUnlWbRaTaLTf/mt36lN83SOpc44b2ZosiFzms/2IpQcsAypW0QFLnx9E",
-	"jMOBa8hc0LJ/bGG3FM15ltxq65taLcVyt8XRaZWQATZFlXyf3WK/b2O21AjrYGE/o8X0aVvpYsSvONtU",
-	"h1UnPNy+ndj2AYd/BWoeJgbGV0iGbqlzgKUt1TDOKgt+q/YiYTOcXMB15ienUeKC6W20WN/WxXBlOJ0Q",
-	"cbHEF0kRtts2N4hY9znjIICv/MepUxO33zXeaoGNBlHXsRdwDVE+tI1SF5cmZ5eJ+b5a3rjwGk2Ii9ie",
-	"n7Z5UjFqWpO6MwugYry3TYCabd3TljabAL946S8bzd7Wa3hdojqkIiRaVZA3RKIB3zBYPQgKIaLGfcdT",
-	"Dwc7gd2QvLo9UGukNCgKvdTXDnAI2q0hEDq01WGD/UP/otB+a87ZH0CHqsGaFothjvNETl7OcSKgGeno",
-	"iiIikL7NQebmErDZI6Olvlsu0QyAIjsXKM71TRJ8TpeAuZwBlihmV1SRhCK2Ag4xmt0gjFKsrGmqWIUy",
-	"4ITF++dU3zqRS/B8RUBjMTXR4oYAsWR5EqMZoJza8JXpOcU0RgXpVyRJVAEBUpGlx7mv7+Z7NDgW8kJI",
-	"zAcr1cqFvH6TqviAkwEVMs5WRAmTmbg1satF0V3q2ZKYti7PKVW8GLbXinAC/t3h9vsdLWNWeKqi0p7l",
-	"yvSV89JSO1X+15WQG7sb0EY7Ecvb3Sgge3nqGPsMR33xRf1PlQ5Mb1osNAV9hqFtf/ONTpVAj6FebX/T",
-	"rY5tY5udToWM/ruQKu0ezNvPW2xzalSFmbcjz2yVje1oNnvVL77Afokn4qIo4zcQ7dWuoKNth1ucsrMG",
-	"YdP6QLxsaDBZrKLJdLJiWsXMteyD+iUXyoigwvwWqX8+BVy49keKU0IX+7+YidhQ+k0jZRaPrgAAW2DD",
-	"4/93IK8Y94R26SudA72Xcw4B/R/0r9Ky/7Zpbn13A2K0cgF9gvPqgaWOBlUdLzTj1EBsa5YOH4os896c",
-	"eEQ/Wxv9dtIYf+fxlOvJzVeXOAWdyHz9runUc/agUylYkXOZSUxAhyWmkzfD1G3JUg++io9bqNsGXR6F",
-	"W+9le79Sa+76xoB1S8cmIdR9JmyT6eqYrB1M1ZqJ2tU0WXHa5LxS1R18VqmPnIeeU6pKXWeU6vsjPJ+s",
-	"MKi90gTOBSsbxosFxxFcmG1jfQdRprHzxA/j+GZ4pX8zQjfrUGQJkeEjtOb1MH1AExxlg34/ZY0+1+xO",
-	"lA7f+oxELwQu55b/8qHOpObLsqN/196HJRS2ik5YYT7tF7ZrDzF4q6r4NA8NZj4qsh5ZEqoX1jUZV0vg",
-	"JuOepVX7HnReKsx1siRCFzqf474PAJk/z5VpwDdsyZCQjOMFIE0+Epia/nqz4uzVO512zJeyoAo3Oym1",
-	"gzxDbx/UFJO9I9xsvNV0d8tai4Fr9aGuIDoCBqxvjmTf6lkAPGgttDPpFRBTFTW4vSgtPAb1FvTP9Saa",
-	"SXC6jYywg0GPZgtDoGBtYOJ3aAIMOp3zXC4KNxw6dRt6sLbJWcXdn2Xd7znUZ3oM9JBnOv2doHrB2PoI",
-	"prZeBI9eFjYzRGtacEb8vxepHDb2n7eyQfgMcVUPSz96NzjoWZhT+RC5Hn/HmvPv0kZrkZ4SeqH97Rcp",
-	"pIGwuqKIuMJZD4+LmSgzLfVJKFhV9+ovdChTnZRWv/UDUDukPujc1j1fA6dwVnD/xUxVaK76AatL7Mjs",
-	"MpfS193lbYNBI3IzzeaCpnVh37poaPKfaww8Vb3TKFIDTL9L3B7U9I4N+hVn2wWWDj9q3EHsaNFEsYT2",
-	"auFMumjYcPBpV1Tp5qekdxsrulnM50UBlguTWr3HWWm/Y9E+YZ4WxFXINkM5y9NSXwxnAwO1qM76caqL",
-	"66xFc7ZG321TFOph871iRb14Ng6V1jfdM5omttk1lkT03w5VCPeg2HzdYrdVJSnIth3tuCoMbBE78FQw",
-	"3HyRfby/Knhf185FWM2EMh1abVixxNqdYuxlLr0wqu1z/plD7vPI+jZPQ/yyrc1Uk0XN9n3MOsHRJV54",
-	"fOCYR8vw2pckELctWey3EBpHYK7+q6aRpirvf1AtdB0eilqanrVHI9PJCrjo5Zt1Hg1bfmp4UJyjVAdu",
-	"yOhg6Ob6y82IRwqrbT/UnbcKDf21S5Vwj+DZz1uorxpVYc7tKJ7iBEsjHA1Kw5JR2M6bSIJ+rCOQLMWs",
-	"vz2wbRqpVKkDOjjMbYCsuOSfDLl8YBDbkQ1BmGOGF8AyWm4F34IeL79c6zuAbsPMb6xz2jnkf0rDVUSF",
-	"bejo08/HmMVwOkkYjhFeuSxsAjFuNuq2caE2qPoIiwPWZuOSzP2raGNDEXzko6DMmahlzktJUh0RSBnd",
-	"q/x1oNCR0xjm/o7tvqVxKuyS9TVndq1hsU1YTY99yVIxclCKtiGbnnVRNz3aWLEkTyG8/ekMX1gamNS4",
-	"32iyd+yOmtiBYq+g4JN4xpJtBL4gxCfvru3tTW3V1P9oVnVf/OmPSyIuGM+WmIbuioTusoZ8Ab2x2Mpr",
-	"pwP3bGxS5SZkSeEaJBjGDMeDZWgAFebrltiokhZASKWfXeBESJcubiFeMyq5TwUmsIKkvmYQ46h0lMUw",
-	"yxfattA/X2GuX9DT2Z2nkzmW2Ewa1TmI9ZqwlnrTazfZZ/nsVeRP11iGZjgiObjVqvyXZd6lQOQzz9m+",
-	"yZlXeUYpIfqllzLrcpHhfjn729E+v+712EDNyeOu4GoKQoN3/sUTzhb+9CREXGSYS4KTPodqG8YFhQ/Z",
-	"whFDrk5oaMrGKxNRumz37dktEnVuMIQyy6cZxWbJLeskdPh91LCMd8Jg9dTisDWouXtkxpPvdW2rZ1fE",
-	"uz2JQUhCi5ymYZWfEmqV4tEakFabDA1Yv0v2KwjhdTNUnj1bc6Zbe+zMVQtaOKlYDM374M+Qaaa01p9p",
-	"vdKWd+g297xnGqQ942i+kLLMU0z3lFmMZwkguM4SbJiLRAYRmZMISWYub7Eoyrl+18iGMp3TzPRYuxdV",
-	"P+vOA094/P3DhxN3GytiMaAvfzv96fV/PXt+9GmKzuybHt98hRZAgev7YbMb0yfjZEEoEiaJ/5zxAHXI",
-	"R1zVyiQyAR9PxJJxOW2yRuRpivlNo3Gk2t1H6I1EZ39///Ht8Tl99/4DMnfKzHu8FcIkC5M5RXAdQSbP",
-	"qRpSlvOMCbWVmSN9+k7+MLPyJewv9qcoF4QuVFWls1eA7NsF55TCgkmiy/5fJACQh63P91985Z2ylqhJ",
-	"4/UX7hTT8CyAPQW4m0CA/8C9gnl1z2sbulkLRxupL0dVkVY/PFN7TeeQUD8878hp7WwH9+agewTQdN4V",
-	"gOTYsIULwzGyYoM9SJxZdSgDLMkqA3zmqv2+jbFaI8xnqlb72IH/on422Hw4UT/qMUXu0Akxjoq3Jiun",
-	"VU1Pgb04m5JrvX/U/gHJc/BZhDbh8KC0yAuXb3PjhMnBc5EheY67cxaX2fJN8mJDtG8Supd0HMd+FfOI",
-	"1vpdXE5Vw5wOMRPWHn1W+epksmcS7MqEeAS9+l343o0pv/TtRtPXfo7FNuQfXbmUbHLfop0rquedC0+K",
-	"iX73Lpp3pm87RhWKsSHiwj5/GQdzkthxdJRQ6iye3fi/83Ib4U3RpT5exPpJ336XGlqvSpRDaNBbI25a",
-	"2VjXu+17gbrBzN1cpHaNbm4GFMj1rG+11jc9zygQuoWJUCVkSPr8CvlezWG+b2Ei1AnrYOGOfFlFc2wx",
-	"mMa3bPEjlfymkxWuTNg95gFBsVj28XWVFboGuKucUhvfEW0+s8NJ94wEo+ErGmyAInfukyZZrrWhWme3",
-	"CWQCxHruTQk5KCqYQ4qJS9SxxsQry06LjrpmqDCvQ7HXgyJDK27B3kF8TYehNdTD4aSNRbqt4M3S1d4t",
-	"LAmVwj53b7cIZEEZB4FwkpgtApIcU6Gjr5HxyApv0hmgkYmIrndBaEwiLEF1g2WjL4GWmMZJ4U1BuhGR",
-	"J9rDomOnhU2EY+iKkW1jeZOpnY5gHGl9EciEQ2yEcp2mS7jZM7d+Mky4MNuiWD8ETSVw7dFT/28m2L7m",
-	"GrEkgUieK17A3hWJAeEZy6Vx97gxVekoJyhxN5o8908WAxRzw+Krj0pCkpjJtL55MkdEutxCkpPFAjjC",
-	"yDZgJxO5REXntDovlEmUZwGusuC7/RVOOG8aXiw4LPSEEioZem9iLfUGFXCM2By9WmGSlDtWU3H/nOoX",
-	"MQUiFLkey9ZjRr+QSEiWIRwCaoD8AcG1IaWwzuSsGKut7BWWO2ZacHKFb4TO/JRNEayAIjyXep702IaN",
-	"bOhrnKJ407kBpeajxrpcHek68YYQZEEhRvrR5bZzDC8GHvn3u9zv9JlTOsVZm5EzI1WlpNQSI7XyH5XH",
-	"YNaCL7yLxZvWehyhVO/1FdVxZ+ubFrwwuJWCZ0Z7O3MRxybQeZbg6DIhQrofFvqESEcMmJRlk+nk30x/",
-	"SgCvzPNfTI/39xxLCdxrsLu7tZ74LiIJ7rHhtC28KcprOLibBj1qfjCFW6Zv0WDRnm9FbHXvWZfsJ3fz",
-	"c8mEREKpdXcXGQGNM0ao3De46X0XFaMrxpNYrxE5Jb/rhabSHiIxUEnmBHj9LXDyO91/dnj4Yu/oUKFi",
-	"P5/lVOYvD49ewjez+AV+Pvv66xfhc9SWGN9kxcXWom99QlDvVUSC9L3sGnzvoMnyzfeaPuw0N0ze3h4q",
-	"ls5HTP/NoXcoHt3YLLfFftRPcA8278iF7ZrdhE8drNkBR9YwYrfj/1AoxIbc6t+d5DYSJTwKDfXd3tGR",
-	"1lB23doXfPUyhtUzerRv6d03o9g/Gq6v8D1prGgJcZ5AV7xMi/JLuPEb8mpryfNht1uLSnMSOEU0SR7z",
-	"KAIhwqUoXA/v3LLqwm5sGA+5Vk2xhtXsMT4r7FxzblAE9rgqhq91LjbZ42NGfei+MfkH0AWHLRYuN5y7",
-	"cpLuIu99dZgD9GOVOT4NbL9vo4JrhPl0cLWP7Z2kpbfEdZCrrUTMrmgZtleNk1Zbg3h2g3Qx87+6sNeC",
-	"1nuH0IlIhtUWGJIe71kXRXtnYK32vBs/Xv3pj97zWSXEA5kPlbukZTDlHJOEmWfnvKHulauVbtoqVeYJ",
-	"XHvn46PwPUJ6r689KhLe6GXVF5aC8+DBOTYh46EcCEN31xWSwgn4cAoiw4GgF46vLgqyeq3BZQ03oGof",
-	"QW5trIn1dHtUSNHqQ20VHAH91WJBsmdC1bctNG5JTIBVOzF3dYRtlHMib5QGTw2BMyxI9MqCXhOktaD6",
-	"tTRWllLqpAEzwBy4K23++skZOf/43w/WlDBN6K/NNm4rzmAbszWxSs/4mZHJ0FHclJw83z96tv/MuDuB",
-	"6rQqk+f7h/uHk0q+swMltgeuYWvMq3kwEbXx5OXkZ5CKcJvNwmWv1bWfHR7as39p07ngLEuICaQ9+Lcw",
-	"JqiZrbXJWVwfeqh11fn+F/Xr7dSSK9mlufKQMV+C3dccsASdAY6DzDlFGP3j7P079L8wQx9UXW2eRwlR",
-	"bIswRbkAhJXZrohg3MYG6sT5MXBEKCJSoDlLEnZF6AJxE8ks9s/pOf2gTwT0DxAjzhIwOecgnUEcQ2xa",
-	"/kJrjS9QlGCSIjJHKZbRUjWmaMkFP6euiM2ObCIK63NxwoSeDD0K89QCTkECF5OXv/n5WxY5OFW0TW6n",
-	"TYal+BppniIXTzBFKb4maZ6aTGLo2YuldlJOXk5+z0FnJLbLSyUCoZzncqNzdJh6tjmf7hhHhj0BIE0n",
-	"L0x3vlYKsg5UIV32qE/ZI1P2eZ+yz1XZr/vQ8LWh4es+7apCVVWlAVFRUr99UhNfVUS/fVITYXzcv5n1",
-	"+5MWMhsCdWC2OQd45swur7i9Up/NuZhJwI9sfXvGZE5pajfZtdycgnHJ2wyO7lTHZNFCJjmWhR+j+jhP",
-	"X0YMiYWNN7M5VDXJd4gyX3aAR423F4ff9in7rSn7XZ+y3w3D8RbYtIDyw3POAUz0pB+fP+nvGkBG7eva",
-	"BZjO6QmHlV5AkwTZ8FOHRoFiiPSeW0x1aLzVbK6cQBJfgrLddUs67VPlMRSTuQXNYM64WpBuao+pFBhW",
-	"+NaOshshIZ2e0wqdV2op0TH5gFJM8UItKCVs+4mDYcEoD5+FPOR0nUR8tCU6ZOIUhFSYDcqDAr7W9e5O",
-	"780mAqJorYpIAnjlbCJz9dwdJocExwiLlRw0QHCmSDCUUywlUGWluU04IuKcAtWhkggvMKG9RMzxdBSy",
-	"pylkJiTFyZg+kg5bRHGMMKJwVeSKrgqZDUkotww4I7pgazfBUZoLqeRE7wwg1hW/4IzJLxS0v1BkfGG2",
-	"HEXljLMIhL7OZHtSpVybJujhhkZLzijLy2r6/phjniol1JJYPAJWa8Msl0sszINjWT5LiFiC2rF8WBJh",
-	"vxNhkhFDrEf3/Xl+ePg8whm5UH/qv+yQmd1auetbHfRP9V5N/Vruxkx3c5KoTc70nO6hfzBCz4ybfRrs",
-	"e4rV7sx+Kn9GX2rl4yavGKUureOoqsryK9fdGxPe1dGdGsZe5XOwyyu1YUx0EnmEa90VvenAog37whTp",
-	"+1jm6pza8ikmmmsNtd70jeivAsrPXNn+hwnNaGxD27cTnRzguM3CwMbSBqaWfhrJc/BvMilcXdjiKaFv",
-	"gS6UND/rve/86+8Rt1BzOmKQ4sSr50zMTVDRncKCCLM+65KFhpAMcUjZChoARimkM20LDNJzb1Xj6xVd",
-	"nYYNNV29kXtWdbXO++k6zZv1ys5Mh0/d1dWcLedXdLqv9ZpOjyKkfnR3NkDTo910F+vUW2cHu9Rvb23M",
-	"2VoF5wzXavs7UGwshr0ryfbMrDyMftu5bknY4iCqpCexqiU4B5VsJoZtIOQPLL7ZmV3t78tjWQuQLjY5",
-	"YQvkLnrUp/LWPwndnH7mVpLPZNUxXKzjogz+DZ1D2DwxLjJ1mPf7nTuue++CaRWJayqdgQnDKOvcpe+6",
-	"Nr6Ond1Tm/h8dlBGLK3TB2WaoLvWBmVPnrlwfm3qNILIZ2U2ITGqhe3RQcVBnKdZRSPUp+A4T7Pa1vr4",
-	"3Rn6g9EifYfPc6PUyLszVfUuXTXH787+xSg8VSGmws5REWbTobXfVNKWD1PZJ1guh2jrdyyG+9HUbkz2",
-	"Cn1rknX4q7sPZO7GT8uLSzS2d4Q+s52mxUodOgcZlsuDP4tomtuDPy8JjW/NT7cHWTUvWnBtaGVRG4o1",
-	"QhXaCiOhD9xMFf1icO/SqgMLzbtZulqM8KDztUmnpFRnAVIHTnthS23g54kOWDM7Vd2Y2qfaO5TVi3ox",
-	"ifV+zj7mvt938RsdL+XmqK84lFbyemHY0FJ+CqLQYIFHCBT7kA3KLK7MjbAdCNvKS8eh9d8+9yvW+VGq",
-	"lzZLz9AMR5dAY1Q+9u11qtjMYgU27jPkqPqe8dM0+Ir3p6tzfkCyHtP+5uSpz7t9cPyzmHmbmCQ45/ZA",
-	"Z6Bn5t7M9uLN0YDJrt3Co7kuykdRi2k/iBLAvCPqVn0WxvUu0JeVWJCpjq2A+CtEaDveT9ub+14fvH58",
-	"XPc6+k6Gz9e6oO7qG4V3KnCiK6z7iTFdrUcHf7p0gbfBENo22E+gGby6kdHOYqjY1WMg0hMIROqJsZhj",
-	"Qvti7FgXHjE2YmwQxnrGWrtF3r+slygs4pK3g2Efh8M/1b7h1AWcnJH47g1Nq82jCDL52MH7mECW5WJ5",
-	"gIVN7BSKPJpzEEtjm6ttoguydPfm9V+6ERQTEbEV8JuwlWmm6iQXy1fCpEz6zBH5maAsJuJyW5CpNoZh",
-	"7Fj1OkLs84BYVjw0uQXGMvP25TCYmccbR5x9Jji7XDwMyi4XI8aePsZEhOlB8/nMbrAVrr5qNRThaAn7",
-	"5/R1cXEMqbYpcHNt3uSyLTPqRvrqpMlwQPWvoKBZSaTKibleplvEthvVVC5MILO5zYUYRzbxJpoDljkH",
-	"gWZYlbH3L81LQtLdL6MLe6/M+igDkcIlUs4iXA6LgBjl4jOQixvBIeu8IP/aKNlS+Zq7YUXNdVr2rOji",
-	"3vD0E+PRuLF+algdcDO4rwencu119OGMULttmQjewN1Tk5ZHr7lV28DegrKXYZ+EhWAP2nZqFtwl6Eum",
-	"rwtqGAFvAF8kFew6aC3SGd61lvxxhZMcy15l36QZcMGoLn6nZzk6ys5lUhwh1QtSBxZPXg36M0ilrcDO",
-	"NsIua1gtxsI0ZDN0oTlJPOt5DaA/36fv+xdDsRhQZQi6bZV7A7kdzqg2h2DcXMsNG6THkIAEJMxLu2KK",
-	"cirAbaWkA70YjPoivEiX/WiouDfkm1ENAf5HNewhFc508Tu1FFiaEjlaxX3QXs+qUHl5J+RB0wWqVyy0",
-	"AaqvzVcSxWi46wygNEYrVj5BJFDM9I0M+3C2M09t5gRwt/q1EUyZTpSvXzJiOa+lWjK3QYT2Ft+gK6Kz",
-	"8MlzKvmN9iHb5E5luid73d4+k6VGsd95w/60eMDmTmziMUQweL2yB1DFMpc6Q3gQqWfLXOok4kUusTAm",
-	"dXouap6FKpFtUvC1EFlDZT39VwacsHhaR6XkN+fUi0gskGCMqn/lEgivvCxt0+7ZUVqCvhDn1CWpUD93",
-	"4/fMsWgogI9d4tT+92XuZQNohnVCRrW+gbxIlnXIigf4G2nxrXW4Arj0iEpOJUlsxryi/sWC4wgujNQp",
-	"oYDrjHCI18iFYsVjdnSMON8A5zr9UHBTqrY+QA2erdmiK4jANXxd5MeVTZdw17b3EIX7lqRE9nO3AJU/",
-	"6XRMd5VORMK1NIzfE5IDTvtjXFM3bkj7YpzP4gOcJMzok07fi1bjfBZb3zJKCWUc0TydaS81jVHGuKzk",
-	"8TPNlp5ka8eH3DHHpz8cvypJedSKtE7qTpD2ODZtCg8t924j4BlktERzzlKEjeLDBhdtJwSac7xIw1lJ",
-	"3LTfm6u47Ox+QDL6f+vAm4bsRBug1RtQqrC2GZOkK0jl4cF1Nxkv6mOz58M+mJXv6Y7X/LdXjmrdE2sX",
-	"SWMM2sIhrac/P+5FTpM4mlK9sNEzlUmfnFH34pO/72wnd5yTyjy2NeakGpKTCh0gsYp0konih5VOOFr5",
-	"IZov6j8IaFTJBd+BYDh30oyxjkOCHxgzKtbmsCkeUPQaAA4cJqDpB/OG+pMSrQ0jyPpXG1TaPB45oMIH",
-	"vBhSmt2PLhnj3wYqjN1Jf6wPidcejW+oAUztUQfceRTpKEm7WHpbK21rLd7t0jvgovsGwneP995H4RuF",
-	"70GXseLV+rAwnbgim8pT0cBnK1LHJmz9lCXJDEeXd3jV561+E3c0t0c99dT01JqgvLMiJK+hodAVkUuE",
-	"EQcBfGUeuO2jtE7PdhL5NqqsUQONGuiJaKBe8WO70z87iNEa1c+ofkb18wTUT79gbx0oveE2beNY6aei",
-	"c0bNMWqOp6g5Ntw49dIZ4x5pNFJGVTOqmoqqUTXi2c0mrhpCka2N0mB6G48GOrNdjopoVESjIhoV0cFm",
-	"rpp++uYz9sqM2mLUFk9QWwzMvLeB1rjXRHxjUMkoTw8sTz3CSj6WhTaXquyzDy0ZA0TGNfyz1jl9Hj5E",
-	"mJqnD9GX5xOTvMk8eng+QZWnEIsnEP3Pbodub7rZd48hfg5XokZUP7prSRqjB3OS1OzYpdb3euqu9zgk",
-	"WJIV7KmmfO/xTtc8Vw4/qeafIsT7XH5mkQR/mo854ymWk5eTGaFYv4Dc5GxgJWjI1os+WdFePJ439V70",
-	"KfviUb6pZ+1NJ8LFn2uWpYSF002cAV+Bfj0gYQsRziPxli3uI6XOW7bon/tGFWZJwq56Fn5LaL8UmYpq",
-	"cceZdDQ9T/eR7zUXug101y0P2wLXLQP3BN5Httu6D1l6aBEZrbc7sN76CaeapThPoM+bDK4skuZVhHnF",
-	"fRJIXmQyvJ+5TsasDb3FxvFslJ1t9/OZsoND8Mbi0uSikQypgjpfbZTkQro8mh1puU5Uy7tPT/PXssUf",
-	"SZa+7RXZmtR7O1Nio9Z4NAaseaWneO7Xi5v/IXBVPOgbBIduaCcP+N5puioiLkdoDIHGgrM8W48NU6wT",
-	"HD/bIo8XHZrCER5D4LHEPL7CHNYjxJUU3Sj5u2vwMQPFETliZQhWSIbjmIMQO1Enb05e2dYeM1IKKkeo",
-	"DIGKfXF7PVBcwU6onBSFHi9QLI0jTIbBREbLPiAxD/53QsQUecwAkdFyhMcgeHA14/KmB0JcyW6QlKUe",
-	"MU4skSNUhkBFYHpAKJEES8bX46Us2gmYs1fv3lRKPmK3yat3qrOC2BE8Q8Hj4jq6cSMxX4AUa1GjJuOv",
-	"AJgRJ0NwkgvooVtUqTUI+SgeeVp4ReCIjSY2zElh5zNR+vjFlCseb7WnMZ0njMN3wQoMQ55b2vaV6xEO",
-	"leCnGiCaa0dgik04zybTfB/Ta4ONnmQYUGjOamEFYhW5mILYXAruSFFtCmjpvlqyxDxzyDgSLNXHcUQK",
-	"xEGwnEcg/BcyzlaRbWbTlWB4jMDQq0f3cBNhPD0eGnHZG8ZAu1H8I90FiE0rI4ZHDO8Mw71f0zFL1/1h",
-	"77HFWJnxh97FeTIrtz/UvPKniTUsC0OtcBln2C+k0N7FxDNWz/7UVn+G//bumi7++UKRR0sQ0jDonznk",
-	"j/0W34vDb/uU/fYvdwXjruWi/X5Lt2Bs9yLLKBmjZPxVJKOdC6NbMrZ7LmWUjFEydnttbxDYF2QFOmVa",
-	"b7j/7GqMgB8B/4h3nJ0v/HRDfOsHe0aMjxh/QKWe5XwxwIA50cVHqI9Q/+tBnUMrvXc32E9thccP9z4Z",
-	"OQYGpQV4odGuOiQc4slLyXO4HQVutJ/86fO75evsLyJdI7ZHbLfSJK+D9uapj0dkj8i+V2RfEXspoye2",
-	"TfnRKipYMRpFo3gNypjdLWDbZsAeF5AR4Q+4zw6ktF6H+Wz0pI6w/yvCPmJ0Thbro9Zem3KPGt3rS/+4",
-	"wkmOZa+yb9IMuGBUF7/7sDjL4PHKwoOERBgxKJIq95GFbTIkP0Ztv+ukx9N6SuoEC7mXspjMCcR7fB49",
-	"f/78O4opq/UQYwl7kqSGs1ICV639v/Pz+M8Xt3vqn2funw/mn5e1f748P99X/3c0/e72q//+13//h5/Y",
-	"UZiGC9N0rTH0l5KLMQ/4mAd8C1HIfZKQj4IwCsLnJAiDDSxrWHkvJP8MEjGOwNroCKNLuLliPHY3k23n",
-	"pqncCB5SJtt++KayEcWfQf7Vty72BtcvhiViQJUhmx5b5d72PnY4423tB5fMPFO2d8clYn0vQnWmfhBT",
-	"lFMBEmEaI/WvFVWxgaw2DciPhpKnIa+GbUPE9aPi65AKZ7r4eKvz/gUsYyzpchecMJZ4cijUBUvnwsbm",
-	"DjNGMxxdgpIpyTheANJdTCdElfxdzfZkOlGlJy/NP9OKom1aXnea94ux5Ak/xaLZXk7ywYoleQrr5vp/",
-	"dKknPONmgJ/JvOezhEQHLAOKM9I19WdXeLHQKZK2Yr6dTJv+43Hzt+CXZpLlGIcE3xykIEQ9mWqLYaeq",
-	"4K+23NB1Xld+Z5Nd9VkmdYXXJqvRm+O7tWerI3uq+Wn0NK9xCDZm+K7CWWrdeLitCETYvDgSY4mVpTrn",
-	"LEUY6VGgJWAuZ4DlpGcMzDp76vCzsqccFIz0m9wr3YJv87NsmT9svdArBTGk/CmJ7yc9mWNBaBFdgCzS",
-	"2Njt07R4nlbvtiSWufjMYGahZZB2tWQ47VyRbYk7Tjn4JgYq1XB2oOcHc+f29vb2/wcAAP//EI25Eny1",
-	"AQA=",
+	"H4sIAAAAAAAC/+x9e3Mbt5LvV0HxbFWSvdTLdrKJb6W2HCvO8Ylj60j22aqNfFXgTJPE0QwwATCUlZS/",
+	"+y285gkMZ0jqYWn+iSMOHo3GrxsNoLvx1yRiacYoUCkmz/+aZJjjFCRw/dfx6U/HLxmdk8VbnIL6JQYR",
+	"cZJJwujk+UQuAc3zJEEZlkvE5kj/QBJARKAY4jyCGM05S/UHqtqYToiq+UcO/Hoynejfnk/sJw5/5IRD",
+	"PHkueQ7TiYiWkGLVr7zOVDkhOaGLyefP08lxzrEho0lVij+h2H3191f5XPYBn3CaJerzt2Iy9XT58won",
+	"OZYeRoD74u+u8rk1pBljCWBqOwAqX5FEAm/3kRAhFY9BFVJcVqX8/RUfy96IhFS0GzUlEXzKOAhBGH2O",
+	"fr8kNP74+zTBM0h+VJTDx/88V6wqGfRu9m+I5JnEMhcfshhLiKcKAz/OGWuzrvgBc46v9UhfpxlwwaiX",
+	"m6T8qIFj2UcYRVggyuIQnysVJ93oeUNSIn08TolEmlcoYjmVgY50OT94jqaTOeMplooeKr97VvKDUAkL",
+	"4IYAtlg30Qlb7GqaMfJMdGWC67O9v79fm21B4h9/wN/D4TP4bm8WHT3Ze/YUvtv7/ml8tDeHo8P426ff",
+	"PQX8X71mXg2cJQm78oBR/66nPGELERq1qb1GlN6wxRtCwcMLDhnjEsklEYjm6Qy4YnaGhUSJ/g9bIKCS",
+	"ExDB2af6W4uA6gQrjSkyHME73TFO2pRQV6RDK7rvXWB+y+KuXlgMSEACkWRVAOyHejXy5dOL9MkU//kj",
+	"5Ede9XiC5bLdPdOqYggBSpF0LgYlQfHsaHoFs/8M0hNmy8Z0bUSHCIu5JUS1LpBkSACNNf7RnPEOUkQf",
+	"wa80XhfpVXQ0RWIVPekltKeQ4OuXSS4k8NfHfkMgMp8RiVFhUzibQCRMqg+M6j+5ai4wNNvMBYm7UD+d",
+	"fNpbsD1bp6TM0apEggZtFmq/bkWoa2SNcJ6SOAxCDoLlPBokn65OAIpz8bejKcm8SDxlCXQgEWcEcZaE",
+	"1JH95MHcf3CYT55P/nZQGpMHppg4UH16MXVmhxzmjmNKgJ7K564JIFQJ4K+ExppmWkqybUfZO536pmt4",
+	"ut2yG2cne7rZwMYt2zTLQLhht0z0UZoShPTCw3bHYugaRgn7Pp0lLMLJkgV7/Kea02NIQBpkeq11/bmP",
+	"untvtxkazUhApI1GyZBpYoquiFyyXKIZx9ElSFE3dCQWl3/L6RWmEuJeitENgAg8S+CUJckMR5fBgZhi",
+	"F9yVW2PE2Nar+47e24s6Y46Bwxw40AimSEQsA4SpUtR0BdoYAnQJ11eMx4jjK6TtwP2SAx6iXjEeBSma",
+	"Mx5Bz9E1tgJD7HrP5CtjRyNAMlTdR1wtgRYbCbpA2I13H52B1D/VilucONb+qBCOOMicU4Ew+gnH6BT+",
+	"yEFIBJwzvt+F71/hOjS0S7julKT6EF+gy5WQjOvZchvqrm5Fd79rBapPh02xqK/NmogaTYrrYbquepJl",
+	"0SoZ4pCyFdQlGehqfxNBfgM4Nnsyr+FvvvbDtYUH8DMShxrkrsyFaNg7xR4yz0l7BHUWlz0Zy0HZQRU6",
+	"OrrvNLIandRbPQMZnEMBctgksgzMeYwzfyBWO/3z/PDwaXR5pf+F382fhMbwyfzy0fzCMvOn+UurLvOD",
+	"UfeIZSghl4B+RP/nR7T3YxsogOWPc54TKYZA5SyfqYGGeGC+rlvfdUvv8SLUjMSLnm2wYBOsXwsfqOiY",
+	"05z2nNXqEqwt6nIRNoK660X4s1KfImNUGAviyeGh+idiVALV84OzLCGRBtjBv4U5Muxn3Z1wNksgNb3U",
+	"x/nuV0XLk8NnbRa8Zeil7f3zdPLsduiprEim16Pb6PUDxblcMk7+hNh0+/Q2un3F+IzEMVDT57Pb6PMt",
+	"k+gVy6kd5/e30aczMd6TFFhuJ/aH2+j5JaPzhES6y29vB8GvqQROcYLOgK+Ao5+VXWX6vxVQqW5JBOgD",
+	"xStMEmWpa/1oq6qWX/AZkRxLxs3Zt74y4Wr5ksRoH1H83kWFrf15Osl54tfKpUn4uy40dU1/LDSgOdxR",
+	"rbzI5fI1nbM2PSnIJbPmllPYQPNUNcsyoNoCmGFBIrXef3v4g+rImBGVnsKmnm2j1W+UEKDywnxqtXIF",
+	"SXJxSdkVvcg5Wc+ARvlppfmPzbJuxCE+vWeXQNsEw6dMtXCBZc38irGEPUkCdq9rqpv6StOujo+4lzjD",
+	"M5IQed2mzp1ldXekS3U3/VpC2m4+xnKt5FTI+zw1hyYVLDV68EEnhfWdvGUx/KbKNYdmD2l0G1ND7/qB",
+	"it6nVA3yPUAvS7whQrZZuEE3opuRup+P0zVzbhljuveyxByOekRU3+yuJdlUN9fAqj19P9CvkppNrSQM",
+	"Mf0qvSso76dLbTWnUhvssYOcumsNS0qnNq0PuZS6Vom3lhWh7++KcYdKlMtIuwRLUyKVDdzGmoiWmC4g",
+	"DuxAqwwoy/qGevz27BQixr0aHAvh1d5OW7Q+BLTUdCJl4rsmcwT10mu28NQSZhrtUAXHb8/+l1HoLZsl",
+	"KzzSf3z60/GLJGFR4XOw/eph1sYhG31zwZESyrifnRnjMnAfWeWnLuYamtbXJxIASuEKEl49iqHMrqX/",
+	"YKpKRHjiMKSMvmGRuRNoLISVi50WRznLpbv0XcOC6jG2qxUm5sRn4mQ14ybI6xBDdcMhMzIqlXYP3WeE",
+	"UrW3FuQV3rZUpW2saMtLNhGXHgTAKrO3vwGY94A1iyHxTyssCKP9V9lTXd4nxoL8CXWhC7loBFXTdLIC",
+	"GtcEMABwLc6OM7bvorYbb6HV3CBDTN/ccNNT5rE0ilZvyljTxNmmuobVf2YLkn0qmojLLUyzkpgAq3Zk",
+	"jh1zsvJZY1ta+KbZLUBiyPKNXX8Rd4uUYnQDJrTkiA8t+us2eKmQFObajkCjHQMdsS0XAn32WRRBRCCM",
+	"3J2+EEq5lCszoVgf67am8RfO8szDC98a51Pf/fCrdWIQxJqGzTFshuCZjLLduwJwQUF/gJVEe+CrP26B",
+	"3go9IX7tCLp/xzy+whwGbTCqCPd9L3Ro61PQDOm307BrdZWAcsNhu7VtdQ12cwwX7PJMS631u0JylYj+",
+	"eKuR7sGz+74FpOuEdbBvR8B+ffIijjkIj/WOyw+tOZoneBFDxiHC0ruBryvXVwleHJfF9XWdnHtbTnEU",
+	"+N2Y7BuKhGp2WgypNQBLkO2mQzYKfm0uHCXLPdNbb/+uxKNGRX/w1on3CEhRYAsJadDm4+FxtZcdyAgV",
+	"EtMINj18dPXL08eUUSIZ71vxN1u892miq1g5TgyO6oW+2X4RRZB5j+nsPcrF8IOeuiNHleWVNrsYHjqq",
+	"wVnmVQXREqJLkaeBjySJubnpKIC29mYo5pnveHI6AboKaEb4dJHiT/6jLfOV0I6vEvMFSH8Bi5sLHAWt",
+	"is6jJcajJQjJrZdaF4TeVYpqi4S76Kr+zAuaMVmCI0iByouMJSS6Xnvf6cqfmOL6kJD5z1kyDhc9+JRx",
+	"wri9pWoz2rknu4WQGO/ekxoMu09vTAOlzLdQrh0YhzG0dfITPvgxrjvr73BNsQqZLGMJW6ydkveu3Ofp",
+	"JDfBUwPOjRv6QAl0RXwrwmok0IhbRbgqklQXm5aMeAExrZ6cVoVi6mxnh3cPVivYqQLFTWjJ+gozazxq",
+	"qTyrNotJNNpv/6W79Sm+7pHUHY4b2ZosiFzms/2IpQcsAypW0QFLnx5EjMOBa8jEqtk/trBbiuY8S261",
+	"9U2tlmK52+LqtErIAJuiSr7PbrHftzFbaoR1sLCf0WL6tK10MeI3nG2qw6oTHm7fTmz7gsO/AjUvEwPj",
+	"KyRDt9Q5wNKWahhnlQW/VXuRsBlOLuBT5ienUeKC6W20WN/WxXBlOJ0QcbHEF0nhtts2N4hY9znjIICv",
+	"/NepUxPC0DXeaoGNBlHXsRfwCaJ8aBulLi5Nzi4T8121vDnCazQhLmJ7f9rmScWoaU3qziyAivHeNgFq",
+	"tnVPW9psAvzipb9sNHtbr+F1ieqQipBoVUHeEIkGfMNg9SAohIga9x1PPRzsBHZD8ur2QK2R0qAo9FJf",
+	"O8AhaLeGQOjSVrsN9nf9i0L7rTlnfwIdqgZrWiyGOc4TOXk+x4mApqejK4qIQDqwhcxNPLTZI6OlDrOX",
+	"aAZAkZ0LFOc6qAaf0yVgLmeAJYrZFVUkoYitgEOMZtcIoxQra5oqVqEMOGHx/jnVAThyCZ6vCGgspsZb",
+	"3BAglixPYjQDlFPrvjI9p5jGqCD9iiSJKiBAKrL0OPd1mgKPBsdCXgiJ+WClWolN7Depig84GVAh42xF",
+	"lDCZiVvju1oU3aWeLYlp6/KcUsWLYXutCCfg3x1uv9/RMmaFpyoq7VmuTF85Ly21U+V/XQm5sbsBbbQT",
+	"sbzdjQL69V9nknH42WYn6GtAV6pd++ar9r2l1WbXNjRzjXvPVMeUrTVPTeCZadRnnFpifoVt/CzrjQQ3",
+	"Do2+tj/vbPfbHoCfS9MNDP/yVKOHs1PV99EG/6nK/UaxDee9iDOBX8fYtwPSEVzqf6oChel1a1imoHcE",
+	"pv3Nd+xVAn3AqbS/6Z7dtrHNlr1CxoAZqtAenppthK9KVZh5uxK5Chvbbpk2fDe+wP6li4iLoox/p2Nj",
+	"FHcksp179bKzBmHT+kC8bGgwWayiyXSyYnqtnOtFDNQvuVDWMBXmt0j98zFwF2F/pDgldLH/q5mIDZcx",
+	"00iZmafLk8UW2NCP5S3IK8Y9Poo6THvgMfycQ8CQCV4U0LL/3uq6w9kwF9DHy7TuIe1oUNXxQjNODcS2",
+	"1qH5LfNen3hEP1vrxnnSGH/nPavryc1XlzgFb0P4+u3/qecSTadHsSLnsg0ZzyRLTCdvhqnbkqUefBUf",
+	"t1C3Dbo8Crfey/YHpK256+vM2C0dm8QC9JmwTaarY7J2MFVrJmpX02TFaZOLd1V38KW79p0YeuGuKnVd",
+	"tqvv9/CivcKg9koTuOCunHxcLDiO4MKcf9S3wmVqSo8jPI6vh1f6NyN0sw5FlhAZvgtuxjnqm8bgKBv0",
+	"+ylr9Llmm610+NaXfXohcHn0/FG0OjuiL3OW/l0foy2hsFV0Ehrzab+wXXuIwRtVxad5aDCbWZHJzJJQ",
+	"zbygybhaAjdZNC2t+hBN55rDXCdAI3Shc7Tu+wCQ+XPXmQZ8w5YMCck4XgDS5COBqemvNyvOXrzVqQR9",
+	"uTeqcLOTUruRNvT2QU0x2TvCzcZbTRck2VoMXKt3FUvrCBiwvjmSfatnAfCgtdDOjllATFXU4PaitDgx",
+	"qLegf6430Uxs1W1khA8Y9Gi2MAQK1gYmfocmwKBrZt/BUbDh0PXx0BviTS7dbv5S9nYvVB/pfeZdXk72",
+	"P83XC8bWd4m19SJ4h7iwKU5a04Iz4v+9yEmy8UVQK62JzxBX9bD0o3eDG8uFcS8Jkes571jjyFHaaC3S",
+	"U0Iv9MXRRQppwD+0KCKucNbjxMVMlJmW+iQUrKpfTy20T16dlFa/9Zt8O6Q+6Nz2nqkGTuGs4P6LmarQ",
+	"XPUDVpfYkdllsiusC0pvg0EjcjPN5rz/dWHfumho8t9rDHQPuFF3aANM/5G4vXHs7eT2G86285Aefme+",
+	"AyfoooliCe3Vwpl0bt1hL+ou9+jNr/tv1ul5M+fliwIsF+a5hB6X/v3u9/v4K1sQVyHb9Ekur/19zsgN",
+	"DNTck+t+Ac5BueaW3Bp9t01RqIfN94oV9eLZOFRa33TPaJrYZtdYEtF/O1Qh3INi83WL3VaVpCDbdrTj",
+	"qjCwRezAW8Fw88WLAv1Vwbu6di78wyaU6RgBw4ol1scpxl7m0guj2j7nnznkvhNZ3+ZpyLlsazPVZFGz",
+	"fR+zTnB0iReeM3DMo2V47UsSiNuWLPZbCI0rMFf/RdNIU5X336sWui4PRS3f1NqrkelkBVz0Opt1Jxq2",
+	"/NTwoLhHqQ7ckNHB0M31l5sRjxRW276r4M0KDf21S5Vwj+DZz1uorxpVYc7tyJ/iBEsjHA1Kw5JR2M6b",
+	"SIJ+gCeQ9cesvz2wbRqpVKkDOjjMbYCsuOSfDLm8YxDbkQ1BmGOGF8AyWm7oedise92nA48PYnkD5fiM",
+	"41g7hGO6MNmTUrYCL8+39V+cuv9bb7u6EDnVUHBqttIExdR6oeda34EWaOyYGiaDPmfzvzTkKqLCzHb0",
+	"6de1jF0xnSQMxwivXGZGgRg3Zx62caH2+vo2kAPWFviSzP0GSWNvFnwDqaDMWftlHlxJUu0lTBndq/x1",
+	"oAQtpzHM/R3bLWDjgt0l8GzO7FobbRsPpR5bvKVi5KC0jUP2j+scmHq0sWJJnkJ4J9npCbI0MKlxv9Fk",
+	"bzcoNbEDNaiCgk+3MZZsI/AFIT55d21vv2tRTf1Ls6o7GLA/Lom4YDxbYhqKHwvFt4eOVXpjsZXrUvtA",
+	"WjevSnR0SeEaJBjGDMeDZWgAFebrltiokhZASKWfXeBESJdCciFeMiq5TwUmsIKkvmYQc+brKIthli+0",
+	"maZ/vsJcPzCqM75PJ3MssZk0qvOS6zVhLfWm126yz/LZi8ifwrVtY3Bwq1X5L8u8S4HIZx43CZNHs/LK",
+	"XEL0Q1hlJvbi1Yvl7G9H+/xTrwdIvDaHpiA0eHdUe8LZwp+yiIiLDHNJcNLnfnJDF6vwfWXY+crVCQ1N",
+	"mctlclr3AkZ7dovkvRsMocz8a0axWcLbOgkdR2hqWOagx2D11OKwNai5e4PLkwN6batnV8S704tBSEKL",
+	"PMdhlZ8SapXi0RqQVpsMDVg/2/gbCOE9sam8Crnmerz2FqSrFrRwUrEYmgvGnzXXTGmtP9N6pS3v0O17",
+	"FJ5pkPa6qPlq0jJPMd1TZjGeJYDgU5Zgw1wkMojInERIMhPQyaIo5/rZN+sVdk4z02MtVrLuNpAHnvX5",
+	"+/v3Jy5CM2IxoK9/P3318r+ePD36OEVn9p2f775BC6DAdczo7Nr0yThZEIqEedhjzniAOuQjrmplEpmA",
+	"jydiybicNlkj8jTF/LrROFLt7iP0WqKzv7/78Ob4nL599x6ZvaR5rrxCmGRhMqcIPkWQyXOqhpTlPGNC",
+	"bWXmSDsykD/NrHwN+4v9KcoFoQtVVensFSD7nsk5pbBgkuiy/xcJAORh69P9Z994p6wlatJcoAh3IWx4",
+	"FsCeAtx1IFZi4F7BPErqtQ3drIUdt9SXo6pIqx+eqL2mO9tRPzztyHPvbAf3JKt7I9V03uXL5diwxWmQ",
+	"Y2TFBrsTl73qUAZYklUG+MxV+30bY7VGmM9Urfaxg/OL+jVr811Z/dDPFLn7O8Q4Kp7irVz8NU8KbDB9",
+	"Sj7p/aM+H5A8B59FaJOQD0qVvnA5eDdOot4jVnR97vPuPOblCxomobkh2jcJ3Us6jmO/irlHa/0uAtbV",
+	"MKdDzIS1t8hVvjqZ7JkYvzIhHkGvfhe+t6TKL3270fS1n2iyDflHVy4lm4SutPPH9Qxf8aSd6RfC0syj",
+	"8LljVCF3JSIu7OvAcTBPkR1HRwmlzuLZtf87L7cR3rR96uNFrF887xcf0nppphxCg94acdPKxrrebd+k",
+	"Cg1m7ia5gmt0czOgQK5nfau1vunVUIHQLUyEKiFDntSokO/VHOb7FiZCnbAOFu7oLKtoji0G0/iGLYLX",
+	"Wa0y4eMxDwiKxbLPWVdZoWuAu8ozt3G4bTP9BCfdMxIMLKhosAGK3B2fNMlyrQ3VOrtNKhUg1hOCJuQg",
+	"B2sOKSa0fnEZMvHKstOio64ZKszrkBv7ICfbyrFgb3/I5oGhNdTDnrmNRbqt4M3S1d4tLAmVJoSo2CKQ",
+	"BWUcBMJJYrYISHJMhXZkR+ZEVngTUQGNjHN5vQtCYxJhCaobLBt9CbTENE6K0xSkGxF5ok9YtBu6sMmx",
+	"DF0xsm0srzO10xGMI60vAtmxiHX2rtN0Cdd7JoAqw4QLsy2K9Tv5VALXJ3rq/80E2xeeI5YkEMlzxQvY",
+	"uyIxIDxjuTTHPW5MVTrKCUpccJgnlGcxQDE3LL76qCQkiZlMezZP5ohIl29McrJYAEcY2QbsZCKXvOyc",
+	"VueFMonyLMDVauqwxmyXnHCnaXix4LDQE0qoZOidcVvVG1TAMWJz9GKFSVLuWE3F/XOqX8kViFDkeixb",
+	"jxn9SiIhWYZwCKgB8gf4KYeUwjqTs2KsthKBWO6YacHJFb4WOhtcNkWwAorwXOp50mMbNrKhL/SK4p33",
+	"BpSaD53rcnWk6xwmQpAFhRjph9jbh2N4MfDKv1+eBKfPnNIp7tqMnBmpKiWlliytlROtvAazFnxxuli8",
+	"c6/HEXr+ob6iOu5sHbTCC4NbKXhmtHfpIWR8xmcJji4TIqT7YaFviLTHgEljOJlO/s30pwTwyjwJyPR4",
+	"/8ixlMC9BrsLU/a4yhFJcI8Np23hdVFew8EFbfSo+d4Ubpm+RYNFe74VsdW9Z12yn1wQ7ZIJiYRS6y6s",
+	"GwGNM0ao3De46R3Wi9EV40ms14ickj/0QlNpD5EYqCRzAnxfv1HpbkrJH3T/yeHhs72jQ4WK/XyWU5k/",
+	"Pzx6Dt/N4mf46ezbb5+F71FbYnydFTHCRd/6hqDeq4gE6Rs3HHwDpcnyzfeaPuw0N0ze3u7KLdFHTP/N",
+	"oXcoHt3YLLfFftRPcA827+gI2zW7CZ86WLMDjqxhxG7H/75QiA251b87yW3knLgXGuqHvaMjraHsurUv",
+	"+Op5DKsn9Gjf0rtvRrF/NFxf4VvSWNES4jyBLn+Z3o60emvJ82GBwkWlOQncIprEr3kUgRDhUhQ+De/c",
+	"surCbmwYDx2tmmINq9ljfFbY2dOZuKji8nZWudhkj48Z9aH7xuQfQBcctli43HBu6pB0F29hVIc5QD9W",
+	"mePTwPb7Niq4RphPB1f72P6QtDwtcR3kaisRsytauu1V/aTV1iCeXSNdzPyvLuy1oPXeIXQjkmG1BYak",
+	"xxv3RdHeWZmrPe/mHK/+HFDv+awS4oHM+0pYbulMOcckYeYpSq+reyVK1U1bpco8gU/e+fggfA8T3+oL",
+	"sIqE13pZ9bml4Dx4cY6Ny3goncTQ3XWFpHAuQ5yCyHDA6YXjq4uCrF5rcFnDDajaR5BbG2tiPd0eFVK0",
+	"eldbBUdAf7VYkOyZUPVtC41bEhNg1U7MXe1hG+WcyGulwVObeh0LEr2woNcEaS2ofi2NlaWUOv/CDDAH",
+	"7kqbv145I+cf//PemhKmCf212cbnymGw9dmaWKVnzpmRSXZSBJ1Onu4fPdl/Yo47geoMNZOn+4f7h5NK",
+	"6rgDJbYHrmFrzKt5MB618eT55BeQinCbGMQlAta1nxwe2rt/aTPj4CxLiHGkPfi3MCaoma21eW5cH3qo",
+	"ddX57lf16+epJVeySxPykDFfruKXHLAEnUyPg8w5RRj94+zdW/Q/MEPvVV1tnkcJUWyLMEW5AISV2a6I",
+	"YNz6BurHNGLgiFBEpEBzliTsitAF4saTWeyf03P6Xt8I6B8gRpwlYNL3QTqDOIbYtPyV1hpfoSjBJEVk",
+	"jlIso6VqTNGSC35OXRGbaNp4FNbn4oQJPRl6FOb5FZyCBC4mz3/387cscnCqaJt8njYZluJPSPMUOX+C",
+	"KUrxJ5LmqUnKhp48W+pDysnzyR856OTOdnmpeCCU81xudI4OU8825+MN48iwJwCk6eSZ6c7XSkHWgSqk",
+	"yx71KXtkyj7tU/apKvttHxq+NTR826ddVaiqqjQgKkrq949q4quK6PePaiLMGffvZv3+qIXMukAdmG3O",
+	"AZ45s8srbi/UZ3MvZh7lQLa+vWMytzS1pABabk7BHMnbZJjuVsckJEMmz5iFH6P6Ok8HI4bEwvqb2XS0",
+	"muQbRJkv0cK9xtuzw+/7lP3elP2hT9kfhuF4C2xaQPnhOecAxnvSj89X+rsGkFH7unYBpnN6wmGlF9Ak",
+	"Qdb91KFRoBgivecWU+0abzWbKyeQxJegbHfdks6gVXkgySTBQTOYM64WpOvaA0sFhhW+9UHZtZCQTs9p",
+	"hc4rtZRon3xAKaZ4oRaUErb9xMGwYJSHRyEPOV0nER9siQ6ZOAUhFWaD8qCAr3W9i+m93kRAFK1VEUkA",
+	"r5xNZELP3WVySHCMsFjJQQMEZ4oEQznFUgJVVprbhCMizilQ7SqJ8AIT2kvEHE9HIXuYQmZcUpyM6Svp",
+	"sEUUxwgjCldF2u2qkFmXhHLLgDOiC7Z2ExyluZBKTvTOAGJd8SvOmPxKQfsrRcZXZstRVM44i0DocCbb",
+	"kyrl2jROD9c0WnJGWV5W0/FjjnmqlFBLYvEwYK0Ns1wusTCPEGb5LCFiCWrH8n5JhP1OhMnrDLEe3Y/n",
+	"+eHh0whn5EL9qf+yQ2Z2a+XCtzron+q9mvq13I2Z7uYkUZuc6TndQ/9ghJ6ZY/ZpsO8pVrsz+6n8GX2t",
+	"lY+bvGKUurT2o6oqy29cd6+Ne1dHd2oYe5XPwS6v1IYx0fn4Ea51V/SmHYs27AtTpOOxTOic2vIpJpqw",
+	"hlpvOiL6m4DyMyHb/zCuGY1taDs60ckBjtssDGwsrWNqeU4jeQ7+TSaFqwtbPCX0DdCFkuYnvfedX/4e",
+	"cQs1pz0GKU68es743AQV3SksiDDrsy5ZaAjJkMn60wAwSiGdaVtgkJ57oxpfr+jqNGyo6eqN3LKqq3Xe",
+	"T9dp3qxXdmY6fOquruZsOb+i032t13R6FCH1o7uzDpoe7aa7WKfeOjvYpX57Y33O1io4Z7hW29+BYmMx",
+	"7F1JtmdTaN2Jftu5bknY4iCqpCexqiU4B5VsJoZtIORPLL7emV3t78tjWQuQzjc5YQvkAj3qU/nZPwnd",
+	"nH7iVpJHsuoYLtZxUTr/hu4hbJ4Y55k67PT7rbuue+ecaRWJayqdgXHDKOvc5Nl1bXwdO7uHNvH57KD0",
+	"WFqnD8o0QTetDcqePHPhzrWp0wgin5XZhMSoFrZHBxUHcZ5mFY1Qn4LjPM1qW+vjt2foT0aL9B2+kxul",
+	"Rt6eqao3eVRz/PbsfxmFhyrEVNg5KtxsOrT260oG+GEq+wTL5RBt/ZbFcDua2o3JhtC3Jlm7v7p4IBMb",
+	"Py0Dl2hsY4Qe2U7TYqUOnYMMy+XBX4U3zeeDvy4JjT+bnz4fZNW8aMG1oZVFbSjWCFVoK4yEPnAzVfTj",
+	"y71Lqw4sNG9m6WoxwoPOlyadklKdBUgdOG3AltrAzxPtsGZ2qroxtU+1MZTVQL2YxHo/p2ORIN7vu/iN",
+	"By/l5qivOJRW8nph2NBSfgii0GCBRwgU+5B1yixC5kbYDoRt5dHo0PpvX04W685RqkGb5cnQDEeXQGNU",
+	"vpvuPVSxmcUKbNymy1H1aeiHafAVT3lX5/yAZD2m/fXJQ593+3b7o5h5m5gkOOf2Qmfgycytme3F860B",
+	"k10fC4/muijfly2m/SBKAPMOr1v1WZijd4G+rviCTLVvBcTfIELb/n7a3tz3nsHrd9x1r+PZyfD5WufU",
+	"XX3u8UYFTnS5dT8wpqv16OAvly7wc9CFtg32E2g6r25ktLMYKnb16Ij0AByRemIs5pjQvhg71oVHjI0Y",
+	"G4Sxnr7WbpH3L+slCgu/5O1g2OfA4Z9q33DqHE7OSHzzhqbV5lEEmbzv4L1PIMtysTzAwiZ2CnkezTmI",
+	"pbHN1TbROVm6uHn9l24ExUREbAX8Omxlmqk6ycXyhTApkx45Ih8JymIiLrcFmWpjGMaOVa8jxB4HxLLi",
+	"zc4tMJaZZ0SHwcy8gzni7JHg7HJxNyi7XIwYe/gYExGmB83nM7vBVhz1VauhCEdL2D+nL4vAMaTapsBN",
+	"2LzJZVtm1I106KTJcED1r6CgWUmkyokJL9MtYtuNaioXxpHZRHMhxpFNvInmgGXOQaAZVmVs/KV5SUi6",
+	"+DK6sHFl9owy4ClcIuUswuWwCIhRLh6BXFwLDllngPxLo2RL5Wtiw4qa67TsWdHFreHpFePRuLF+aFgd",
+	"EBnc9wSnEvY6nuGMUPvcMhG8jrunJi2PXnOrtoGNgrLBsA/CQrAXbTs1C24S9CXT1zk1jIA3gC+SCnZd",
+	"tBbpDG9aS/68wkmOZa+yr9MMuGBUF7/RuxztZecyKY6Q6gWpA4snrwb9BaTSVmBnG2GXNazmY2Eashm6",
+	"0JwknvW8BtBfbvPs+1dDsRhQZQi6bZVbA7kdzqg2h2DchOWGDdJjSEACEualXTFFORXgtlLSgV4MRn3h",
+	"XqTLfjBU3BryzaiGAP+DGvaQCme6+I1aCixNiRyt4j5or2dVqLy8EzpB0wWqIRbaANVh85VEMRruOgMo",
+	"jdGKlU8QCRQzHZFhH8525qnNnAAuql8bwZTpRPn6JSOW81qqJRMNIvRp8TW6IjoLnzynkl/rM2Sb3KlM",
+	"92TD7e0zWWoU+50R9qfFAzY3YhOPLoLB8MoeQBXLXOoM4UGkni1zqZOIF7nEwpjU6bmoeRaqRLZJwddC",
+	"ZA2V9fRfGXDC4mkdlZJfn1MvIrFAgjGq/pVLILzysrRNu2dHaQn6SpxTl6RC/dyN3zPHoqEAPnaJU/vH",
+	"y9zKBtAM64SMan0DeZEs65AVD/A30uJb63AFcOkRlZxKktiMeUX9iwXHEVwYqVNCAZ8ywiFeIxeKFff5",
+	"oGPE+QY41+mHgptStfUBavBszRZdQQTC8HWRn1c2XcJN295DFO4bkhLZ77gFqHyl0zHdVDoRCZ+kYfye",
+	"kBxw2h/jmrpxQ9oX43wWH+AkYUafdJ69aDXOZ7E9W0YpoYwjmqczfUpNY5QxLit5/Eyz5UmyteNDxzHH",
+	"pz8dvyhJudeKtE7qTpB2PzZtCg+t492GwzPIaInmnKUIG8WHDS7ahxBozvEiDWclcdN+a0fFZWe3A5Lx",
+	"/LcOvGnITrQOWr0BpQprmzFJupxU7h5cN5Pxoj42ez/sg1n5nu4Y5r+9clTrnli7SBpj0BYOaT39+X4v",
+	"cprE0ZTqhY2eqUz65Iy6lTP52852csM5qcxjW2NOqiE5qdABEqtIJ5kofljphKOVH6L5ov6DgEaVXPAd",
+	"CIY7Tpox1nFJ8BNjRsXaHDbFA4peA8CBwzg0/WTeUH9QorWhB1n/aoNKm8cjB1R4jxdDSrPb0SWj/9tA",
+	"hbE76Y/1JfHaq/ENNYCpPeqAG/ciHSVpF0tva6VtrcW7XXoHBLpvIHy3GPc+Ct8ofHe6jBWv1oeF6cQV",
+	"2VSeigYerUgdG7f1U5YkMxxd3mCozxv9Ju5obo966qHpqTVOeWeFS15DQ6ErIpcIIw4C+Mo8cNtHaZ2e",
+	"7cTzbVRZowYaNdAD0UC9/Md2p3924KM1qp9R/Yzq5wGon37O3tpResNt2sa+0g9F54yaY9QcD1FzbLhx",
+	"6qUzxj3SaKSMqmZUNRVVo2rEs+tNjmoIRbY2SoPpbTwa6Mx2OSqiURGNimhURAebHdX00zeP+FRm1Baj",
+	"tniA2mJg5r0NtMatJuIbnUpGebpjeerhVvKhLLS5VGWP3rVkdBAZ1/BHrXP6PHyIMDVPH6KvzycmeZN5",
+	"9PB8gipPIRZPIPqf3Q5Fb7rZd48hPoaQqBHV9y4sSWP0YE6Smh271PpeT92nPQ4JlmQFe6op33u80zXP",
+	"lcMr1fxDhHif4GcWSfCn+ZgznmI5eT6ZEYr1C8hNzgZWgoZsPeuTFe3Z/XlT71mfss/u5Zt61t50Ilz8",
+	"uWZZSlg43cQZ8BXo1wMSthDhPBJv2OI2Uuq8YYv+uW9UYZYk7Kpn4TeE9kuRqagWN5xJR9PzcB/5XhPQ",
+	"baC7bnnYFrhuGbgl8N6z3dZtyNJdi8hovd2A9dZPONUsxXkCfd5kcGWRNK8izCvHJ4HkRSbD+5nrZMza",
+	"0FtsHM9G2dl2P58pOzgEbywuTS4ayZAqqPPVRkkupMuj2ZGW60S1vPv0NF+WLX5PsvRtr8jWpN7bmRIb",
+	"tca9MWDNKz3Fc79e3PyLwFXxoG8QHLqhnTzge6Ppqoi4HKExBBoLzvJsPTZMsU5w/GKL3F90aApHeAyB",
+	"xxLz+ApzWI8QV1J0o+TvrsH7DBRH5IiVIVghGY5jDkLsRJ28PnlhW7vPSCmoHKEyBCr2xe31QHEFO6Fy",
+	"UhS6v0CxNI4wGQYTGS37gMQ8+N8JEVPkPgNERssRHoPgwdWMy+seCHElu0FSlrrHOLFEjlAZAhWB6QGh",
+	"RBIsGV+Pl7JoJ2DOXrx9XSl5j49NXrxVnRXEjuAZCh7n19GNG4n5AqRYixo1GV8CYEacDMFJLqCHblGl",
+	"1iDkg7jnaeEVgSM2mtgwN4Wdz0Tp6xdTrni81d7GdN4wDt8FKzAMeW5p21euRzhUnJ9qgGiuHYEpNu48",
+	"m0zzbUyvdTZ6kG5AoTmruRWIVeR8CmITFNyRotoU0NJ9tWSJeeaQcSRYqq/jiBSIg2A5j0D4AzLOVpFt",
+	"ZtOVYLiPwNDQo1uIRBhvj4d6XPaGMdBuFP9MdwFi08qI4RHDO8Nw79d0zNJ1e9i7bz5WZvyhd3EezMrt",
+	"dzWv/Gl8DcvCUCtc+hn2cym0sZh4xurZn9rqz/Dfxq7p4o8XijxagpCGQf/MIb/vUXzPDr/vU/b7Ly4E",
+	"46blov1+S7dgbPciyygZo2R8KZLRzoXRLRnbPZcySsYoGbsN2xsE9gVZgU6Z1hvuv7gaI+BHwN/jHWfn",
+	"Cz/dEN/6wZ4R4yPG71CpZzlfDDBgTnTxEeoj1L88qHNopffuBvuprXD/4d4nI8dAp7QALzTaVYeEQzx5",
+	"LnkOn0eBG+0nf/r8bvk6+0Kka8T2iO1WmuR10N489fGI7BHZt4rsK2KDMnpi25QfraKCFaNRNIrXoIzZ",
+	"3QK2bQbscQEZEX6H++xASut1mM/Gk9QR9l8i7CNG52Sx3mvtpSl3r9G9vvTPK5zkWPYq+zrNgAtGdfGb",
+	"d4uzDB5DFu7EJcKIQZFUuY8sbJMh+T5q+10nPZ7WU1InWMi9lMVkTiDe4/Po6dOnP1BMWa2HGEvYkyQ1",
+	"nJUSuGrt/52fx389+7yn/nni/nlv/nle++fr8/N99X9H0x8+f/Pf//vf/+EndhSm4cI0XWsMfVFyMeYB",
+	"H/OAbyEKuU8S8lEQRkF4TIIw2MCyhpU3IPkXkIhxBNZGRxhdwvUV47GLTLadm6ZyI3hImWz74UhlI4q/",
+	"gPzSty42gutXwxIxoMqQTY+tcmt7HzucMVr7ziUzz5Tt3RFErOMiVGfqBzFFORUgEaYxUv9aURUbyGrT",
+	"gPxgKHkY8mrYNkRcPyi+DqlwpouPUZ33VcAuV0Iy3uNc4dd/nemCD2alEje8eBh+/UwlJ6CzQTxKLPfc",
+	"sbjkhQ3lq37+guB3U3fjig1tPK2/GP/S9i0P4crjRtTzAVDJr43d4yJG66JilvKarPys6zwYfT1aETeh",
+	"eXst+o8ASTd2+TBib+Mj+weNvls42XxY5sG9RHDnSfuI3xG/9xm/w83QS7Vt7ntUoPfYj9bjrGSCOz8e",
+	"cdiBw4yxpAtZJ4wlHjTVj4H1y23YZNzDaIajS6AxUtDFC0C6i+mEqJJ/KGU2mU5U6clz88+0MrNNbXSj",
+	"WeoZSx7ww8Ga7eUkH6xYkqewbq7/pUs94Bk3A3wk857PEhIdsAwozkjX1J9d4cVCJ/Teivl2Mm2y2vvN",
+	"34JfmkmWYxwSfH2QghD1p39aDDtVBX+z5YYutrryW5uavc/iqSu8NDm4Xx/f7AJaHdlDzaasp3nNXrgx",
+	"wzcVfFXrxsNtRSDC5n3cGEssQKI5ZynCSI8CLQFzOQMsJz0jttZZ7oePynJ3UDDSbzIFdwu+zSa8Zbb7",
+	"9UKvFMSQ8qckvp1k+o4FoUV0AbJIumwv+6coZZRIxo1vgMQyF48MZhZaBmlXS4bTzhXZlrjhBzJex0Cl",
+	"Gs4O9Pxg7qi92f8PAAD//4TWSrRJzQEA",
 }
 
 // GetSwagger returns the content of the embedded swagger specification file
diff --git a/daemon/api/codegen_type_gen.go b/daemon/api/codegen_type_gen.go
index 5d600e548..0b44bc57c 100644
--- a/daemon/api/codegen_type_gen.go
+++ b/daemon/api/codegen_type_gen.go
@@ -96,6 +96,11 @@ const (
 	InstanceListKindInstanceList InstanceListKind = "InstanceList"
 )
 
+// Defines values for KVStoreKeyListKind.
+const (
+	KVStoreKeyListKindKVStoreKeyList KVStoreKeyListKind = "KVStoreKeyList"
+)
+
 // Defines values for KeywordItemKind.
 const (
 	KeywordItemKindKeywordItem KeywordItemKind = "KeywordItem"
@@ -158,6 +163,13 @@ const (
 	PacthItem PatchItemKind = "PacthItem"
 )
 
+// Defines values for PatchKVStoreEntryAction.
+const (
+	Add    PatchKVStoreEntryAction = "add"
+	Change PatchKVStoreEntryAction = "change"
+	Remove PatchKVStoreEntryAction = "remove"
+)
+
 // Defines values for PatchListKind.
 const (
 	PatchListKindPatchList PatchListKind = "PatchList"
@@ -621,6 +633,35 @@ type InstanceMonitor = instance.Monitor
 // InstanceStatus defines model for InstanceStatus.
 type InstanceStatus = instance.Status
 
+// KVStoreEntries defines model for KVStoreEntries.
+type KVStoreEntries = []KVStoreEntry
+
+// KVStoreEntry defines model for KVStoreEntry.
+type KVStoreEntry struct {
+	Bytes []byte `json:"bytes"`
+	Key   string `json:"key"`
+}
+
+// KVStoreKeyList defines model for KVStoreKeyList.
+type KVStoreKeyList struct {
+	Items KVStoreKeyListItems `json:"items"`
+	Kind  KVStoreKeyListKind  `json:"kind"`
+}
+
+// KVStoreKeyListKind defines model for KVStoreKeyList.Kind.
+type KVStoreKeyListKind string
+
+// KVStoreKeyListItem defines model for KVStoreKeyListItem.
+type KVStoreKeyListItem struct {
+	Key    string `json:"key"`
+	Node   string `json:"node"`
+	Object string `json:"object"`
+	Size   int    `json:"size"`
+}
+
+// KVStoreKeyListItems defines model for KVStoreKeyListItems.
+type KVStoreKeyListItems = []KVStoreKeyListItem
+
 // KeywordData defines model for KeywordData.
 type KeywordData struct {
 	Value any `json:"value"`
@@ -903,6 +944,20 @@ type PatchItemKind string
 // PatchItems defines model for PatchItems.
 type PatchItems = []PatchItem
 
+// PatchKVStoreEntries defines model for PatchKVStoreEntries.
+type PatchKVStoreEntries = []PatchKVStoreEntry
+
+// PatchKVStoreEntry defines model for PatchKVStoreEntry.
+type PatchKVStoreEntry struct {
+	Action PatchKVStoreEntryAction `json:"action"`
+	Bytes  *[]byte                 `json:"bytes,omitempty"`
+	Key    string                  `json:"key"`
+	String *string                 `json:"string,omitempty"`
+}
+
+// PatchKVStoreEntryAction defines model for PatchKVStoreEntry.Action.
+type PatchKVStoreEntryAction string
+
 // PatchList defines model for PatchList.
 type PatchList struct {
 	Items PatchItems    `json:"items"`
@@ -1390,6 +1445,12 @@ type InQueryForce = bool
 // InQueryImpersonate The node name to impersonate when evaluating a keyword. Setting impersonate without evaluate=true returns a Bad Request error.
 type InQueryImpersonate = string
 
+// InQueryKey A kvstore key name
+type InQueryKey = string
+
+// Keys defines model for inQueryKeys.
+type Keys = []string
+
 // InQueryKeywords defines model for inQueryKeywords.
 type InQueryKeywords = []string
 
@@ -1785,6 +1846,31 @@ type PostObjectConfigUpdateParams struct {
 	Set    *InQuerySets    `form:"set,omitempty" json:"set,omitempty"`
 }
 
+// GetObjectKVStoreParams defines parameters for GetObjectKVStore.
+type GetObjectKVStoreParams struct {
+	Keys *Keys `form:"key,omitempty" json:"key,omitempty"`
+}
+
+// DeleteObjectKVStoreEntryParams defines parameters for DeleteObjectKVStoreEntry.
+type DeleteObjectKVStoreEntryParams struct {
+	Key InQueryKey `form:"key" json:"key"`
+}
+
+// GetObjectKVStoreEntryParams defines parameters for GetObjectKVStoreEntry.
+type GetObjectKVStoreEntryParams struct {
+	Key InQueryKey `form:"key" json:"key"`
+}
+
+// PostObjectKVStoreEntryParams defines parameters for PostObjectKVStoreEntry.
+type PostObjectKVStoreEntryParams struct {
+	Key InQueryKey `form:"key" json:"key"`
+}
+
+// PutObjectKVStoreEntryParams defines parameters for PutObjectKVStoreEntry.
+type PutObjectKVStoreEntryParams struct {
+	Key InQueryKey `form:"key" json:"key"`
+}
+
 // GetPoolsParams defines parameters for GetPools.
 type GetPoolsParams struct {
 	// Name the name of a backend storage pool
@@ -1839,5 +1925,8 @@ type PostObjectActionRestartJSONRequestBody = PostObjectActionRestart
 // PostObjectActionSwitchJSONRequestBody defines body for PostObjectActionSwitch for application/json ContentType.
 type PostObjectActionSwitchJSONRequestBody = PostObjectActionSwitch
 
+// PatchObjectKVStoreJSONRequestBody defines body for PatchObjectKVStore for application/json ContentType.
+type PatchObjectKVStoreJSONRequestBody = PatchKVStoreEntries
+
 // PostRelayMessageJSONRequestBody defines body for PostRelayMessage for application/json ContentType.
 type PostRelayMessageJSONRequestBody = PostRelayMessage
diff --git a/daemon/api/unstructured.go b/daemon/api/unstructured.go
index 3187a5a55..45bdbc0d1 100644
--- a/daemon/api/unstructured.go
+++ b/daemon/api/unstructured.go
@@ -507,3 +507,16 @@ func (t PoolVolume) Unstructured() map[string]any {
 		"size":      t.Size,
 	}
 }
+
+func (t KVStoreKeyList) GetItems() any {
+	return t.Items
+}
+
+func (t KVStoreKeyListItem) Unstructured() map[string]any {
+	return map[string]any{
+		"node":   t.Node,
+		"object": t.Object,
+		"key":    t.Key,
+		"size":   t.Size,
+	}
+}
diff --git a/daemon/daemonapi/delete_object_kvstore_entry.go b/daemon/daemonapi/delete_object_kvstore_entry.go
new file mode 100644
index 000000000..87e9c1b3a
--- /dev/null
+++ b/daemon/daemonapi/delete_object_kvstore_entry.go
@@ -0,0 +1,67 @@
+package daemonapi
+
+import (
+	"errors"
+	"net/http"
+
+	"github.com/labstack/echo/v4"
+
+	"github.com/opensvc/om3/core/instance"
+	"github.com/opensvc/om3/core/naming"
+	"github.com/opensvc/om3/core/object"
+	"github.com/opensvc/om3/daemon/api"
+	"github.com/opensvc/om3/daemon/rbac"
+)
+
+func (a *DaemonAPI) DeleteObjectKVStoreEntry(ctx echo.Context, namespace string, kind naming.Kind, name string, params api.DeleteObjectKVStoreEntryParams) error {
+	log := LogHandler(ctx, "DeleteObjectKVStoreEntry")
+
+	if v, err := assertGrant(ctx, rbac.NewGrant(rbac.RoleAdmin, namespace), rbac.GrantRoot); !v {
+		return err
+	}
+
+	p, err := naming.NewPath(namespace, kind, name)
+	if err != nil {
+		return JSONProblemf(ctx, http.StatusBadRequest, "Invalid parameters", "%s", err)
+	}
+	log = naming.LogWithPath(log, p)
+
+	instanceConfigData := instance.ConfigData.GetByPath(p)
+
+	if _, ok := instanceConfigData[a.localhost]; ok {
+		ks, err := object.NewKeystore(p)
+
+		switch {
+		case errors.Is(err, object.ErrWrongType):
+			return JSONProblemf(ctx, http.StatusBadRequest, "NewKeystore", "%s", err)
+		case err != nil:
+			return JSONProblemf(ctx, http.StatusInternalServerError, "NewKeystore", "%s", err)
+		}
+
+		err = ks.RemoveKey(params.Key)
+		switch {
+		case errors.Is(err, object.KeystoreErrNotExist):
+			return ctx.NoContent(http.StatusNoContent)
+		case errors.Is(err, object.KeystoreErrKeyEmpty):
+			return JSONProblemf(ctx, http.StatusBadRequest, "RemoveKey", "%s: %s", params.Key, err)
+		case err != nil:
+			return JSONProblemf(ctx, http.StatusInternalServerError, "RemoveKey", "%s: %s", params.Key, err)
+		default:
+			return ctx.NoContent(http.StatusNoContent)
+		}
+	}
+
+	for nodename := range instanceConfigData {
+		c, err := newProxyClient(ctx, nodename)
+		if err != nil {
+			return JSONProblemf(ctx, http.StatusInternalServerError, "New client", "%s: %s", nodename, err)
+		}
+		if resp, err := c.DeleteObjectKVStoreEntryWithResponse(ctx.Request().Context(), namespace, kind, name, &params); err != nil {
+			return JSONProblemf(ctx, http.StatusInternalServerError, "Request peer", "%s: %s", nodename, err)
+		} else if len(resp.Body) > 0 {
+			return ctx.JSONBlob(resp.StatusCode(), resp.Body)
+		}
+	}
+
+	return nil
+}
diff --git a/daemon/daemonapi/get_object_kvstore.go b/daemon/daemonapi/get_object_kvstore.go
new file mode 100644
index 000000000..525672e68
--- /dev/null
+++ b/daemon/daemonapi/get_object_kvstore.go
@@ -0,0 +1,70 @@
+package daemonapi
+
+import (
+	"errors"
+	"net/http"
+
+	"github.com/labstack/echo/v4"
+
+	"github.com/opensvc/om3/core/instance"
+	"github.com/opensvc/om3/core/naming"
+	"github.com/opensvc/om3/core/object"
+	"github.com/opensvc/om3/daemon/api"
+	"github.com/opensvc/om3/daemon/rbac"
+)
+
+func (a *DaemonAPI) GetObjectKVStore(ctx echo.Context, namespace string, kind naming.Kind, name string, params api.GetObjectKVStoreParams) error {
+	log := LogHandler(ctx, "GetObjectKVStore")
+
+	if v, err := assertGrant(ctx, rbac.NewGrant(rbac.RoleAdmin, namespace), rbac.GrantRoot); !v {
+		return err
+	}
+
+	result := make(api.KVStoreEntries, 0)
+
+	p, err := naming.NewPath(namespace, kind, name)
+	if err != nil {
+		return JSONProblemf(ctx, http.StatusBadRequest, "Invalid parameters", "%s", err)
+	}
+	log = naming.LogWithPath(log, p)
+
+	instanceConfigData := instance.ConfigData.GetByPath(p)
+
+	if _, ok := instanceConfigData[a.localhost]; ok {
+		ks, err := object.NewKeystore(p)
+
+		switch {
+		case errors.Is(err, object.ErrWrongType):
+			return JSONProblemf(ctx, http.StatusBadRequest, "NewKeystore", "%s", err)
+		case err != nil:
+			return JSONProblemf(ctx, http.StatusInternalServerError, "NewKeystore", "%s", err)
+		}
+
+		if params.Keys == nil {
+			return ctx.JSON(http.StatusOK, result)
+		}
+
+		for _, key := range *params.Keys {
+			if b, err := ks.DecodeKey(key); err != nil {
+				return JSONProblemf(ctx, http.StatusInternalServerError, "DecodeKey", "%s: %s", key, err)
+			} else {
+				result = append(result, api.KVStoreEntry{Key: key, Bytes: b})
+			}
+		}
+		return ctx.JSON(http.StatusOK, result)
+	}
+
+	for nodename := range instanceConfigData {
+		c, err := newProxyClient(ctx, nodename)
+		if err != nil {
+			return JSONProblemf(ctx, http.StatusInternalServerError, "New client", "%s: %s", nodename, err)
+		}
+		if resp, err := c.GetObjectKVStoreWithResponse(ctx.Request().Context(), namespace, kind, name, &params); err != nil {
+			return JSONProblemf(ctx, http.StatusInternalServerError, "Request peer", "%s: %s", nodename, err)
+		} else if len(resp.Body) > 0 {
+			return ctx.JSONBlob(resp.StatusCode(), resp.Body)
+		}
+	}
+
+	return nil
+}
diff --git a/daemon/daemonapi/get_object_kvstore_entry.go b/daemon/daemonapi/get_object_kvstore_entry.go
new file mode 100644
index 000000000..2129b7755
--- /dev/null
+++ b/daemon/daemonapi/get_object_kvstore_entry.go
@@ -0,0 +1,69 @@
+package daemonapi
+
+import (
+	"errors"
+	"net/http"
+	"unicode/utf8"
+
+	"github.com/labstack/echo/v4"
+
+	"github.com/opensvc/om3/core/instance"
+	"github.com/opensvc/om3/core/naming"
+	"github.com/opensvc/om3/core/object"
+	"github.com/opensvc/om3/daemon/api"
+	"github.com/opensvc/om3/daemon/rbac"
+)
+
+func (a *DaemonAPI) GetObjectKVStoreEntry(ctx echo.Context, namespace string, kind naming.Kind, name string, params api.GetObjectKVStoreEntryParams) error {
+	log := LogHandler(ctx, "GetObjectKVStoreEntry")
+
+	if v, err := assertGrant(ctx, rbac.NewGrant(rbac.RoleAdmin, namespace), rbac.GrantRoot); !v {
+		return err
+	}
+
+	p, err := naming.NewPath(namespace, kind, name)
+	if err != nil {
+		return JSONProblemf(ctx, http.StatusBadRequest, "Invalid parameters", "%s", err)
+	}
+	log = naming.LogWithPath(log, p)
+
+	instanceConfigData := instance.ConfigData.GetByPath(p)
+
+	if _, ok := instanceConfigData[a.localhost]; ok {
+		ks, err := object.NewKeystore(p)
+
+		switch {
+		case errors.Is(err, object.ErrWrongType):
+			return JSONProblemf(ctx, http.StatusBadRequest, "NewKeystore", "%s", err)
+		case err != nil:
+			return JSONProblemf(ctx, http.StatusInternalServerError, "NewKeystore", "%s", err)
+		}
+
+		if b, err := ks.DecodeKey(params.Key); err != nil {
+			return JSONProblemf(ctx, http.StatusInternalServerError, "DecodeKey", "%s: %s", params.Key, err)
+		} else {
+			var contentType string
+			if utf8.Valid(b) {
+				contentType = "text/plain"
+			} else {
+				contentType = "application/octet-stream"
+			}
+			return ctx.Blob(http.StatusOK, contentType, b)
+		}
+		return ctx.NoContent(http.StatusNoContent)
+	}
+
+	for nodename := range instanceConfigData {
+		c, err := newProxyClient(ctx, nodename)
+		if err != nil {
+			return JSONProblemf(ctx, http.StatusInternalServerError, "New client", "%s: %s", nodename, err)
+		}
+		if resp, err := c.GetObjectKVStoreEntryWithResponse(ctx.Request().Context(), namespace, kind, name, &params); err != nil {
+			return JSONProblemf(ctx, http.StatusInternalServerError, "Request peer", "%s: %s", nodename, err)
+		} else if len(resp.Body) > 0 {
+			return ctx.JSONBlob(resp.StatusCode(), resp.Body)
+		}
+	}
+
+	return nil
+}
diff --git a/daemon/daemonapi/get_object_kvstore_keys.go b/daemon/daemonapi/get_object_kvstore_keys.go
new file mode 100644
index 000000000..9a0cf8a49
--- /dev/null
+++ b/daemon/daemonapi/get_object_kvstore_keys.go
@@ -0,0 +1,74 @@
+package daemonapi
+
+import (
+	"errors"
+	"net/http"
+
+	"github.com/labstack/echo/v4"
+
+	"github.com/opensvc/om3/core/instance"
+	"github.com/opensvc/om3/core/naming"
+	"github.com/opensvc/om3/core/object"
+	"github.com/opensvc/om3/daemon/api"
+	"github.com/opensvc/om3/daemon/rbac"
+	"github.com/opensvc/om3/util/key"
+)
+
+func (a *DaemonAPI) GetObjectKVStoreKeys(ctx echo.Context, namespace string, kind naming.Kind, name string) error {
+	log := LogHandler(ctx, "GetObjectKVStore")
+
+	if v, err := assertGrant(ctx, rbac.NewGrant(rbac.RoleAdmin, namespace), rbac.GrantRoot); !v {
+		return err
+	}
+
+	p, err := naming.NewPath(namespace, kind, name)
+	if err != nil {
+		return JSONProblemf(ctx, http.StatusBadRequest, "Invalid parameters", "%s", err)
+	}
+	log = naming.LogWithPath(log, p)
+
+	instanceConfigData := instance.ConfigData.GetByPath(p)
+
+	if _, ok := instanceConfigData[a.localhost]; ok {
+		ks, err := object.NewKeystore(p)
+
+		switch {
+		case errors.Is(err, object.ErrWrongType):
+			return JSONProblemf(ctx, http.StatusBadRequest, "NewKeystore", "%s", err)
+		case err != nil:
+			return JSONProblemf(ctx, http.StatusInternalServerError, "NewKeystore", "%s", err)
+		}
+
+		if names, err := ks.AllKeys(); err != nil {
+			return JSONProblemf(ctx, http.StatusInternalServerError, "Keys", "%s", err)
+		} else {
+			items := make(api.KVStoreKeyListItems, 0)
+			for _, name := range names {
+				items = append(items, api.KVStoreKeyListItem{
+					Object: p.String(),
+					Node:   a.localhost,
+					Key:    name,
+					Size:   len(ks.Config().GetString(key.T{"data", name})),
+				})
+			}
+			return ctx.JSON(http.StatusOK, api.KVStoreKeyList{
+				Kind:  "KVStoreKeyList",
+				Items: items,
+			})
+		}
+	}
+
+	for nodename := range instanceConfigData {
+		c, err := newProxyClient(ctx, nodename)
+		if err != nil {
+			return JSONProblemf(ctx, http.StatusInternalServerError, "New client", "%s: %s", nodename, err)
+		}
+		if resp, err := c.GetObjectKVStoreKeysWithResponse(ctx.Request().Context(), namespace, kind, name); err != nil {
+			return JSONProblemf(ctx, http.StatusInternalServerError, "Request peer", "%s: %s", nodename, err)
+		} else if len(resp.Body) > 0 {
+			return ctx.JSONBlob(resp.StatusCode(), resp.Body)
+		}
+	}
+
+	return nil
+}
diff --git a/daemon/daemonapi/patch_object_kvstore.go b/daemon/daemonapi/patch_object_kvstore.go
new file mode 100644
index 000000000..479a701ee
--- /dev/null
+++ b/daemon/daemonapi/patch_object_kvstore.go
@@ -0,0 +1,115 @@
+package daemonapi
+
+import (
+	"errors"
+	"net/http"
+
+	"github.com/labstack/echo/v4"
+
+	"github.com/opensvc/om3/core/instance"
+	"github.com/opensvc/om3/core/naming"
+	"github.com/opensvc/om3/core/object"
+	"github.com/opensvc/om3/daemon/api"
+	"github.com/opensvc/om3/daemon/rbac"
+)
+
+func (a *DaemonAPI) PatchObjectKVStore(ctx echo.Context, namespace string, kind naming.Kind, name string) error {
+	log := LogHandler(ctx, "PatchObjectKVStore")
+
+	if v, err := assertGrant(ctx, rbac.NewGrant(rbac.RoleAdmin, namespace), rbac.GrantRoot); !v {
+		return err
+	}
+
+	var (
+		patches api.PatchKVStoreEntries
+	)
+
+	if err := ctx.Bind(&patches); err != nil {
+		return JSONProblemf(ctx, http.StatusBadRequest, "Invalid body", "error: %s", err)
+	}
+
+	if len(patches) == 0 {
+		return ctx.NoContent(http.StatusNoContent)
+	}
+
+	p, err := naming.NewPath(namespace, kind, name)
+	if err != nil {
+		return JSONProblemf(ctx, http.StatusBadRequest, "Invalid parameters", "%s", err)
+	}
+	log = naming.LogWithPath(log, p)
+
+	instanceConfigData := instance.ConfigData.GetByPath(p)
+
+	getBytes := func(patch api.PatchKVStoreEntry) ([]byte, error) {
+		switch {
+		case patch.Bytes == nil && patch.String == nil:
+			return nil, JSONProblemf(ctx, http.StatusBadRequest, "Invalid parameters", "bytes or string is required to add or change key %s", patch.Key)
+		case patch.Bytes != nil && patch.String != nil:
+			return nil, JSONProblemf(ctx, http.StatusBadRequest, "Invalid parameters", "only one of bytes or string is allowed to add or change key %s", patch.Key)
+		case patch.Bytes != nil:
+			return *patch.Bytes, nil
+		case patch.String != nil:
+			return []byte(*patch.String), nil
+		default:
+			// no way to get here, just to please the builder
+			return nil, nil
+		}
+	}
+
+	if _, ok := instanceConfigData[a.localhost]; ok {
+		ks, err := object.NewKeystore(p)
+
+		switch {
+		case errors.Is(err, object.ErrWrongType):
+			return JSONProblemf(ctx, http.StatusBadRequest, "NewKeystore", "%s", err)
+		case err != nil:
+			return JSONProblemf(ctx, http.StatusInternalServerError, "NewKeystore", "%s", err)
+		}
+
+		for _, patch := range patches {
+			switch patch.Action {
+			case "add":
+				b, err := getBytes(patch)
+				if err != nil {
+					return err
+				}
+				if err := ks.TransactionAddKey(patch.Key, b); err != nil {
+					return JSONProblemf(ctx, http.StatusInternalServerError, "AddKey", "%s: %s", patch.Key, err)
+				}
+			case "change":
+				b, err := getBytes(patch)
+				if err != nil {
+					return err
+				}
+				if err := ks.TransactionChangeKey(patch.Key, b); err != nil {
+					return JSONProblemf(ctx, http.StatusInternalServerError, "ChangeKey", "%s: %s", patch.Key, err)
+				}
+			case "remove":
+				if err := ks.TransactionRemoveKey(patch.Key); err != nil {
+					return JSONProblemf(ctx, http.StatusInternalServerError, "RemoveKey", "%s: %s", patch.Key, err)
+				}
+			default:
+				return JSONProblemf(ctx, http.StatusBadRequest, "Invalid parameters", "%s: action %s is not supported, use add, change or remove", patch.Key, patch.Action)
+			}
+		}
+
+		if err := ks.Config().CommitInvalid(); err != nil {
+			return JSONProblemf(ctx, http.StatusInternalServerError, "Commit", "%s", err)
+		}
+		return ctx.NoContent(http.StatusNoContent)
+	}
+
+	for nodename := range instanceConfigData {
+		c, err := newProxyClient(ctx, nodename)
+		if err != nil {
+			return JSONProblemf(ctx, http.StatusInternalServerError, "New client", "%s: %s", nodename, err)
+		}
+		if resp, err := c.PatchObjectKVStoreWithResponse(ctx.Request().Context(), namespace, kind, name, patches); err != nil {
+			return JSONProblemf(ctx, http.StatusInternalServerError, "Request peer", "%s: %s", nodename, err)
+		} else if len(resp.Body) > 0 {
+			return ctx.JSONBlob(resp.StatusCode(), resp.Body)
+		}
+	}
+
+	return nil
+}
diff --git a/daemon/daemonapi/post_object_kvstore_entry.go b/daemon/daemonapi/post_object_kvstore_entry.go
new file mode 100644
index 000000000..30d5358fe
--- /dev/null
+++ b/daemon/daemonapi/post_object_kvstore_entry.go
@@ -0,0 +1,72 @@
+package daemonapi
+
+import (
+	"errors"
+	"io/ioutil"
+	"net/http"
+
+	"github.com/labstack/echo/v4"
+
+	"github.com/opensvc/om3/core/instance"
+	"github.com/opensvc/om3/core/naming"
+	"github.com/opensvc/om3/core/object"
+	"github.com/opensvc/om3/daemon/api"
+	"github.com/opensvc/om3/daemon/rbac"
+)
+
+func (a *DaemonAPI) PostObjectKVStoreEntry(ctx echo.Context, namespace string, kind naming.Kind, name string, params api.PostObjectKVStoreEntryParams) error {
+	log := LogHandler(ctx, "PostObjectKVStoreEntry")
+
+	if v, err := assertGrant(ctx, rbac.NewGrant(rbac.RoleAdmin, namespace), rbac.GrantRoot); !v {
+		return err
+	}
+
+	p, err := naming.NewPath(namespace, kind, name)
+	if err != nil {
+		return JSONProblemf(ctx, http.StatusBadRequest, "Invalid parameters", "%s", err)
+	}
+	log = naming.LogWithPath(log, p)
+
+	instanceConfigData := instance.ConfigData.GetByPath(p)
+
+	if _, ok := instanceConfigData[a.localhost]; ok {
+		ks, err := object.NewKeystore(p)
+
+		switch {
+		case errors.Is(err, object.ErrWrongType):
+			return JSONProblemf(ctx, http.StatusBadRequest, "NewKeystore", "%s", err)
+		case err != nil:
+			return JSONProblemf(ctx, http.StatusInternalServerError, "NewKeystore", "%s", err)
+		}
+
+		b, err := ioutil.ReadAll(ctx.Request().Body)
+		if err != nil {
+			return JSONProblemf(ctx, http.StatusInternalServerError, "ReadAll", "%s: %s", params.Key, err)
+		}
+		err = ks.AddKey(params.Key, b)
+		switch {
+		case errors.Is(err, object.KeystoreErrExist):
+			return JSONProblemf(ctx, http.StatusConflict, "AddKey", "%s: %s. consider using the PUT method.", params.Key, err)
+		case errors.Is(err, object.KeystoreErrKeyEmpty):
+			return JSONProblemf(ctx, http.StatusBadRequest, "AddKey", "%s: %s", params.Key, err)
+		case err != nil:
+			return JSONProblemf(ctx, http.StatusInternalServerError, "AddKey", "%s: %s", params.Key, err)
+		default:
+			return ctx.NoContent(http.StatusNoContent)
+		}
+	}
+
+	for nodename := range instanceConfigData {
+		c, err := newProxyClient(ctx, nodename)
+		if err != nil {
+			return JSONProblemf(ctx, http.StatusInternalServerError, "New client", "%s: %s", nodename, err)
+		}
+		if resp, err := c.PostObjectKVStoreEntryWithBodyWithResponse(ctx.Request().Context(), namespace, kind, name, &params, "application/octet-stream", ctx.Request().Body); err != nil {
+			return JSONProblemf(ctx, http.StatusInternalServerError, "Request peer", "%s: %s", nodename, err)
+		} else if len(resp.Body) > 0 {
+			return ctx.JSONBlob(resp.StatusCode(), resp.Body)
+		}
+	}
+
+	return nil
+}
diff --git a/daemon/daemonapi/put_object_kvstore_entry.go b/daemon/daemonapi/put_object_kvstore_entry.go
new file mode 100644
index 000000000..f7fe5e415
--- /dev/null
+++ b/daemon/daemonapi/put_object_kvstore_entry.go
@@ -0,0 +1,78 @@
+package daemonapi
+
+import (
+	"errors"
+	"io/ioutil"
+	"net/http"
+	"slices"
+
+	"github.com/labstack/echo/v4"
+
+	"github.com/opensvc/om3/core/instance"
+	"github.com/opensvc/om3/core/naming"
+	"github.com/opensvc/om3/core/object"
+	"github.com/opensvc/om3/daemon/api"
+	"github.com/opensvc/om3/daemon/rbac"
+)
+
+func (a *DaemonAPI) PutObjectKVStoreEntry(ctx echo.Context, namespace string, kind naming.Kind, name string, params api.PutObjectKVStoreEntryParams) error {
+	log := LogHandler(ctx, "PutObjectKVStoreEntry")
+
+	if v, err := assertGrant(ctx, rbac.NewGrant(rbac.RoleAdmin, namespace), rbac.GrantRoot); !v {
+		return err
+	}
+
+	p, err := naming.NewPath(namespace, kind, name)
+	if err != nil {
+		return JSONProblemf(ctx, http.StatusBadRequest, "Invalid parameters", "%s", err)
+	}
+	log = naming.LogWithPath(log, p)
+
+	instanceConfigData := instance.ConfigData.GetByPath(p)
+
+	if _, ok := instanceConfigData[a.localhost]; ok {
+		ks, err := object.NewKeystore(p)
+
+		switch {
+		case errors.Is(err, object.ErrWrongType):
+			return JSONProblemf(ctx, http.StatusBadRequest, "NewKeystore", "%s", err)
+		case err != nil:
+			return JSONProblemf(ctx, http.StatusInternalServerError, "NewKeystore", "%s", err)
+		}
+
+		keys, err := ks.AllKeys()
+		if err != nil {
+			return JSONProblemf(ctx, http.StatusInternalServerError, "AllKeys", "%s", err)
+		}
+		if !slices.Contains(keys, params.Key) {
+			return JSONProblemf(ctx, http.StatusNotFound, "ChangeKey", "%s: %s. consider using the POST method.", params.Key, err)
+		}
+		b, err := ioutil.ReadAll(ctx.Request().Body)
+		if err != nil {
+			return JSONProblemf(ctx, http.StatusInternalServerError, "ReadAll", "%s: %s", params.Key, err)
+		}
+		err = ks.ChangeKey(params.Key, b)
+		switch {
+		case errors.Is(err, object.KeystoreErrKeyEmpty):
+			return JSONProblemf(ctx, http.StatusBadRequest, "ChangeKey", "%s: %s", params.Key, err)
+		case err != nil:
+			return JSONProblemf(ctx, http.StatusInternalServerError, "ChangeKey", "%s: %s", params.Key, err)
+		default:
+			return ctx.NoContent(http.StatusNoContent)
+		}
+	}
+
+	for nodename := range instanceConfigData {
+		c, err := newProxyClient(ctx, nodename)
+		if err != nil {
+			return JSONProblemf(ctx, http.StatusInternalServerError, "New client", "%s: %s", nodename, err)
+		}
+		if resp, err := c.PutObjectKVStoreEntryWithBodyWithResponse(ctx.Request().Context(), namespace, kind, name, &params, "application/octet-stream", ctx.Request().Body); err != nil {
+			return JSONProblemf(ctx, http.StatusInternalServerError, "Request peer", "%s: %s", nodename, err)
+		} else if len(resp.Body) > 0 {
+			return ctx.JSONBlob(resp.StatusCode(), resp.Body)
+		}
+	}
+
+	return nil
+}
diff --git a/util/uri/uri.go b/util/uri/uri.go
index 6d3fcca55..235755fe8 100644
--- a/util/uri/uri.go
+++ b/util/uri/uri.go
@@ -1,14 +1,17 @@
 package uri
 
 import (
+	"bufio"
 	"errors"
 	"fmt"
 	"io"
 	"net/http"
 	"net/url"
 	"os"
+	"path/filepath"
 
 	"github.com/opensvc/om3/core/rawconfig"
+	"github.com/opensvc/om3/util/file"
 )
 
 type (
@@ -17,6 +20,11 @@ type (
 	}
 )
 
+var (
+	ErrFromUnknown = errors.New("from is unknown")
+	ErrFromEmpty   = errors.New("from is empty")
+)
+
 func New(s string) T {
 	return T{
 		uri: s,
@@ -69,3 +77,77 @@ func IsValid(s string) bool {
 	}
 	return true
 }
+
+func ReadAllFrom(from string) (map[string][]byte, error) {
+	switch from {
+	case "":
+		return nil, ErrFromEmpty
+	case "-", "stdin", "/dev/stdin":
+		return readAllFromStdin()
+	default:
+		u := New(from)
+		if u.IsValid() {
+			return readAllFromURI(u)
+		}
+		if v, err := file.ExistsAndRegular(from); err != nil {
+			return nil, err
+		} else if v {
+			return readAllFromRegular(from)
+		}
+		if v, err := file.ExistsAndDir(from); err != nil {
+			return nil, err
+		} else if v {
+			return readAllFromDir(from)
+		}
+		return nil, ErrFromUnknown
+	}
+}
+
+func readAllFromStdin() (map[string][]byte, error) {
+	m := make(map[string][]byte)
+	stat, _ := os.Stdin.Stat()
+	if (stat.Mode() & os.ModeCharDevice) == 0 {
+		reader := bufio.NewReader(os.Stdin)
+		b, err := io.ReadAll(reader)
+		m[""] = b
+		return m, err
+	}
+	return m, fmt.Errorf("stdin must be a pipe")
+}
+
+func readAllFromRegular(p string) (map[string][]byte, error) {
+	m := make(map[string][]byte)
+	b, err := os.ReadFile(p)
+	m[""] = b
+	return m, err
+}
+
+func readAllFromDir(p string) (map[string][]byte, error) {
+	m := make(map[string][]byte)
+	err := filepath.Walk(p, func(path string, info os.FileInfo, err error) error {
+		if err != nil {
+			return err
+		}
+		if info.Mode().IsRegular() {
+			b, err := os.ReadFile(path)
+			if err != nil {
+				return err
+			}
+			if err != nil {
+				return err
+			}
+			m[path] = append([]byte{}, b...)
+		}
+		return nil
+	})
+	return m, err
+}
+
+func readAllFromURI(u T) (map[string][]byte, error) {
+	fName, err := u.Fetch()
+	if err != nil {
+		return nil, err
+	}
+	defer os.Remove(fName)
+	return readAllFromRegular(fName)
+}